@gatling.io/core 3.11.7 → 3.12.0

package/src/structure/asLongAs.ts

@@ -0,0 +1,121 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { On, wrapOn } from "./on";
+
+import JvmAsLongAs = io.gatling.javaapi.core.loop.AsLongAs;
+
+export interface AsLongAsFunction<T extends AsLongAs<T>> {
+  /**
+   * Define a loop that will iterate as long as the condition holds true
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, counterName: string, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true
+   *
+   * @param condition - the condition, expressed as a function
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true
+   *
+   * @param condition - the condition, expressed as a function
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, exitASAP: boolean): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true
+   *
+   * @param condition - the condition, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, counterName: string): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true
+   *
+   * @param condition - the condition, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, counterName: string, exitASAP: boolean): On<T>;
+}
+
+export interface AsLongAs<T extends AsLongAs<T>> {
+  asLongAs: AsLongAsFunction<T>;
+}
+
+export const asLongAsImpl =
+  <J2, J1 extends JvmAsLongAs<J2, any>, T extends AsLongAs<T>>(
+    jvmAsLongAs: J1,
+    wrap: (wrapped: J2) => T
+  ): AsLongAsFunction<T> =>
+  (condition: SessionTo<boolean> | string, arg1?: boolean | string, arg2?: boolean) => {
+    if (arg2 !== undefined && typeof arg1 === "string") {
+      // asLongAs(condition, counterName, exitASAP)
+      if (typeof condition === "function") {
+        return wrapOn(jvmAsLongAs.asLongAs(underlyingSessionTo(condition), arg1, arg2), wrap);
+      } else {
+        return wrapOn(jvmAsLongAs.asLongAs(condition, arg1, arg2), wrap);
+      }
+    } else if (typeof arg1 === "string") {
+      // asLongAs(condition, counterName)
+      if (typeof condition === "function") {
+        return wrapOn(jvmAsLongAs.asLongAs(underlyingSessionTo(condition), arg1), wrap);
+      } else {
+        return wrapOn(jvmAsLongAs.asLongAs(condition, arg1), wrap);
+      }
+    } else if (typeof arg1 === "boolean") {
+      // asLongAs(condition, exitASAP)
+      if (typeof condition === "function") {
+        return wrapOn(jvmAsLongAs.asLongAs(underlyingSessionTo(condition), arg1), wrap);
+      } else {
+        return wrapOn(jvmAsLongAs.asLongAs(condition, arg1), wrap);
+      }
+    } else if (arg1 === undefined) {
+      // asLongAs(condition)
+      if (typeof condition === "function") {
+        return wrapOn(jvmAsLongAs.asLongAs(underlyingSessionTo(condition)), wrap);
+      } else {
+        return wrapOn(jvmAsLongAs.asLongAs(condition), wrap);
+      }
+    }
+
+    throw Error(`asLongAs() called with invalid arguments ${condition}, ${arg1}, ${arg2}`);
+  };

package/src/structure/asLongAsDuring.ts

@@ -0,0 +1,337 @@
+import { Duration, isDuration, toJvmDuration } from "../utils/duration";
+import { SessionTo, underlyingSessionTo, underlyingSessionToDuration } from "../session";
+
+import { On, wrapOn } from "./on";
+
+import JvmAsLongAsDuring = io.gatling.javaapi.core.loop.AsLongAsDuring;
+
+export interface AsLongAsDuringFunction<T extends AsLongAsDuring<T>> {
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @returns a DSL component for defining the loop content
+   */
+  (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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a function
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: SessionTo<Duration>): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a function
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: string, duration: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the loop content
+   */
+  (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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a Gatling Expression Language String
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a Gatling Expression Language String
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (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
+   *
+   * @param condition - the condition, expressed as a Gatling Expression Language String
+   * @param duration - the maximum duration, expressed as a Gatling Expression Language String
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (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
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, in seconds or with an explicit time unit
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, expressed as a function
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: SessionTo<Duration>): On<T>;
+
+  /**
+   * Define a loop that will iterate as long as the condition holds true and a maximum duration
+   * isn't reached
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, expressed as a function
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: SessionTo<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
+   *
+   * @param condition - the condition, expressed as a function
+   * @param duration - the maximum duration, expressed as a function
+   * @param counterName - the name of the loop counter, as stored in the Session
+   * @param exitASAP - if the loop must be interrupted if the condition becomes false or the maximum duration is reached
+   * inside the loop
+   * @returns a DSL component for defining the loop content
+   */
+  (condition: SessionTo<boolean>, duration: SessionTo<Duration>, counterName: string, exitASAP: boolean): On<T>;
+}
+
+export interface AsLongAsDuring<T extends AsLongAsDuring<T>> {
+  asLongAsDuring: AsLongAsDuringFunction<T>;
+}
+
+export const asLongAsDuringImpl =
+  <J2, J1 extends JvmAsLongAsDuring<J2, any>, T extends AsLongAsDuring<T>>(
+    jvmAsLongAsDuring: J1,
+    wrap: (wrapped: J2) => T
+  ): AsLongAsDuringFunction<T> =>
+  (
+    condition: SessionTo<boolean> | string,
+    duration: Duration | SessionTo<Duration> | string,
+    arg2?: string | boolean,
+    arg3?: boolean
+  ) => {
+    if (arg3 !== undefined && typeof arg2 === "string") {
+      // asLongAsDuring(condition, duration, counterName, exitASAP)
+      if (typeof condition === "function") {
+        const wrappedCondition = underlyingSessionTo(condition);
+        if (isDuration(duration)) {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, toJvmDuration(duration), arg2, arg3), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, underlyingSessionToDuration(duration), arg2, arg3),
+            wrap
+          );
+        }
+      } else {
+        if (isDuration(duration)) {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(condition, toJvmDuration(duration), arg2, arg3), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmAsLongAsDuring.asLongAsDuring(condition, underlyingSessionToDuration(duration), arg2, arg3),
+            wrap
+          );
+        }
+      }
+    } else if (typeof arg2 === "string") {
+      // asLongAsDuring(condition, duration, counterName)
+      if (typeof condition === "function") {
+        const wrappedCondition = underlyingSessionTo(condition);
+        if (isDuration(duration)) {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, toJvmDuration(duration), arg2), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, underlyingSessionToDuration(duration), arg2),
+            wrap
+          );
+        }
+      } else {
+        if (isDuration(duration)) {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(condition, toJvmDuration(duration), arg2), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(condition, underlyingSessionToDuration(duration), arg2), wrap);
+        }
+      }
+    } else if (typeof arg2 === "boolean") {
+      // asLongAsDuring(condition, duration, exitASAP)
+      if (typeof condition === "function") {
+        const wrappedCondition = underlyingSessionTo(condition);
+        if (isDuration(duration)) {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, toJvmDuration(duration), arg2), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, underlyingSessionToDuration(duration), arg2),
+            wrap
+          );
+        }
+      } else {
+        if (isDuration(duration)) {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(condition, toJvmDuration(duration), arg2), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(condition, underlyingSessionToDuration(duration), arg2), wrap);
+        }
+      }
+    } else if (arg2 === undefined) {
+      // asLongAsDuring(condition, duration)
+      if (typeof condition === "function") {
+        const wrappedCondition = underlyingSessionTo(condition);
+        if (isDuration(duration)) {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, toJvmDuration(duration)), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(
+            jvmAsLongAsDuring.asLongAsDuring(wrappedCondition, underlyingSessionToDuration(duration)),
+            wrap
+          );
+        }
+      } else {
+        if (isDuration(duration)) {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(condition, toJvmDuration(duration)), wrap);
+        } else if (typeof duration === "function") {
+          return wrapOn(jvmAsLongAsDuring.asLongAsDuring(condition, underlyingSessionToDuration(duration)), wrap);
+        }
+      }
+    }
+
+    throw Error(`asLongAsDuring() called with invalid arguments ${condition}, ${duration}, ${arg2}, ${arg3}`);
+  };

package/src/structure/choices.ts

@@ -0,0 +1,41 @@
+import { CoreDsl as JvmCoreDsl } from "@gatling.io/jvm-types";
+
+import { Wrapper } from "../common";
+import { Executable } from "./execs";
+
+import JvmChoiceWithKey = io.gatling.javaapi.core.Choice$WithKey;
+import JvmChoiceWithKeyThen = io.gatling.javaapi.core.WithKey$Then;
+import JvmChoiceWithWeight = io.gatling.javaapi.core.Choice$WithWeight;
+import JvmChoiceWithWeightThen = io.gatling.javaapi.core.WithWeight$Then;
+
+export interface ChoiceWithKey extends Wrapper<JvmChoiceWithKey> {}
+const wrapChoiceWithKey = (_underlying: JvmChoiceWithKey): ChoiceWithKey => ({
+  _underlying
+});
+
+interface ChoiceWithKeyThen {
+  then(executable: Executable<any>, ...executables: Executable<any>[]): ChoiceWithKey;
+}
+
+const wrapChoiceWithKeyThen = (jvmChoiceWithKeyThen: JvmChoiceWithKeyThen): ChoiceWithKeyThen => ({
+  then: (executable: Executable<any>, ...executables: Executable<any>[]): ChoiceWithKey =>
+    wrapChoiceWithKey(jvmChoiceWithKeyThen.then(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+
+export const onCase = (key: unknown): ChoiceWithKeyThen => wrapChoiceWithKeyThen(JvmCoreDsl.onCase(key));
+
+export interface ChoiceWithWeight extends Wrapper<JvmChoiceWithWeight> {}
+const wrapChoiceWithWeight = (_underlying: JvmChoiceWithWeight): ChoiceWithWeight => ({
+  _underlying
+});
+
+interface ChoiceWithWeightThen {
+  then(executable: Executable<any>, ...executables: Executable<any>[]): ChoiceWithWeight;
+}
+
+const wrapChoiceWithWeightThen = (jvmChoiceWithWeightThen: JvmChoiceWithWeightThen): ChoiceWithWeightThen => ({
+  then: (executable: Executable<any>, ...executables: Executable<any>[]): ChoiceWithWeight =>
+    wrapChoiceWithWeight(jvmChoiceWithWeightThen.then(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+
+export const percent = (percent: number): ChoiceWithWeightThen => wrapChoiceWithWeightThen(JvmCoreDsl.percent(percent));

package/src/structure/doIf.ts

@@ -0,0 +1,140 @@
+import { SessionTo, underlyingSessionTo } from "../session";
+import { Executable } from "./execs";
+
+import JvmDoIf = io.gatling.javaapi.core.condition.DoIf;
+import JvmDoIfEquals = io.gatling.javaapi.core.condition.DoIfEquals;
+import JvmExecutable = io.gatling.javaapi.core.exec.Executable;
+
+// DoIf$Then and DoIfEquals$Then are equivalent for us
+interface JvmThen<T> {
+  then(executable: JvmExecutable, ...executables: JvmExecutable[]): T;
+}
+
+export interface Then<T> {
+  then(executable: Executable<any>, ...executables: Executable<any>[]): T;
+}
+
+const wrapThen = <J, T>(jvmThen: JvmThen<J>, wrap: (underlying: J) => T): Then<T> => ({
+  then: (executable: Executable<any>, ...executables: Executable<any>[]): T =>
+    wrap(jvmThen.then(executable._underlying, ...executables.map((e) => e._underlying)))
+});
+
+export interface DoIfFunction<T extends DoIf<T>> {
+  /**
+   * Execute the "then" block only if the condition is true
+   *
+   * @param 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
+   */
+  (condition: string): Then<T>;
+
+  /**
+   * Execute the "then" block only if the condition is true
+   *
+   * @param condition - the condition expressed as a function
+   * @returns a DSL component for defining the "then" block
+   */
+  (condition: SessionTo<boolean>): Then<T>;
+}
+
+export interface DoIf<T extends DoIf<T>> {
+  doIf: DoIfFunction<T>;
+}
+
+export const doIfImpl =
+  <J2, J1 extends JvmDoIf<J2, any>, T extends DoIf<T>>(jvmDoIf: J1, wrap: (wrapped: J2) => T): DoIfFunction<T> =>
+  (condition: string | SessionTo<boolean>) =>
+    wrapThen(
+      typeof condition === "function" ? jvmDoIf.doIf(underlyingSessionTo(condition)) : jvmDoIf.doIf(condition),
+      wrap
+    );
+
+export interface DoIfEqualsFunction<T extends DoIfEquals<T>> {
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a Gatling Expression Language String
+   * @param expected - the expected value expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: string, expected: string): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a Gatling Expression Language String
+   * @param expected - the expected static value
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: string, expected: unknown): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a Gatling Expression Language String
+   * @param expected - the expected value expressed as a function
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: string, expected: SessionTo<unknown>): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a function
+   * @param expected - the expected value expressed as a Gatling Expression Language String
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: SessionTo<unknown>, expected: string): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a function
+   * @param expected - the expected static value
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: SessionTo<unknown>, expected: unknown): Then<T>;
+
+  /**
+   * Execute the "then" block only if the actual value is equal to the expected one
+   *
+   * @param actual - the actual value expressed as a function
+   * @param expected - the expected value expressed as a function
+   * @returns a DSL component for defining the "then" block
+   */
+  (actual: SessionTo<unknown>, expected: SessionTo<unknown>): Then<T>;
+}
+
+export interface DoIfEquals<T extends DoIfEquals<T>> {
+  doIfEquals: DoIfEqualsFunction<T>;
+}
+
+export const doIfEqualsImpl =
+  <J2, J1 extends JvmDoIfEquals<J2, any>, T extends DoIfEquals<T>>(
+    jvmDoIfEquals: J1,
+    wrap: (wrapped: J2) => T
+  ): DoIfEqualsFunction<T> =>
+  (actual: string | SessionTo<unknown>, expected: string | SessionTo<unknown> | unknown) => {
+    if (typeof actual === "function") {
+      const wrappedActual = underlyingSessionTo(actual);
+      if (typeof expected === "function") {
+        return wrapThen(
+          jvmDoIfEquals.doIfEquals(wrappedActual, underlyingSessionTo(expected as SessionTo<unknown>)),
+          wrap
+        );
+      } else if (typeof expected === "string") {
+        return wrapThen(jvmDoIfEquals.doIfEquals(wrappedActual, expected), wrap);
+      } else {
+        return wrapThen(jvmDoIfEquals.doIfEquals(wrappedActual, expected), wrap);
+      }
+    } else {
+      if (typeof expected === "function") {
+        return wrapThen(jvmDoIfEquals.doIfEquals(actual, underlyingSessionTo(expected as SessionTo<unknown>)), wrap);
+      } else if (typeof expected === "string") {
+        return wrapThen(jvmDoIfEquals.doIfEquals(actual, expected), wrap);
+      } else {
+        return wrapThen(jvmDoIfEquals.doIfEquals(actual, expected), wrap);
+      }
+    }
+  };