Action7<State, System, T1, T2, T3, T4, T5, T6, T7, R> constructor

Action7<State, System, T1, T2, T3, T4, T5, T6, T7, R>(
  1. String description,
  2. Arbitrary<T1> arbitrary1,
  3. Arbitrary<T2> arbitrary2,
  4. Arbitrary<T3> arbitrary3,
  5. Arbitrary<T4> arbitrary4,
  6. Arbitrary<T5> arbitrary5,
  7. Arbitrary<T6> arbitrary6,
  8. Arbitrary<T7> arbitrary7, {
  9. required void nextState(
    1. State,
    2. T1,
    3. T2,
    4. T3,
    5. T4,
    6. T5,
    7. T6,
    8. T7,
    ),
  10. required R run(
    1. System,
    2. T1,
    3. T2,
    4. T3,
    5. T4,
    6. T5,
    7. T6,
    8. T7,
    ),
  11. bool precondition(
    1. State,
    2. T1,
    3. T2,
    4. T3,
    5. T4,
    6. T5,
    7. T6,
    8. T7,
    )?,
  12. bool postcondition(
    1. State,
    2. T1,
    3. T2,
    4. T3,
    5. T4,
    6. T5,
    7. T6,
    8. T7,
    9. R,
    )?,
})

Creates a new action command with 7 arbitraries.

Parameters:

  • description: The description of the action.
  • arbitrary1: The arbitrary used to generate the first value.
  • arbitrary2: The arbitrary used to generate the second value.
  • arbitrary3: The arbitrary used to generate the third value.
  • arbitrary4: The arbitrary used to generate the fourth value.
  • arbitrary5: The arbitrary used to generate the fifth value.
  • arbitrary6: The arbitrary used to generate the sixth value.
  • arbitrary7: The arbitrary used to generate the seventh value.
  • run: A function to perform the action.
  • precondition: A function to test the precondition of the action.
  • postcondition: A function to test the postcondition of the action.

Implementation

Action7(
  String description,
  Arbitrary<T1> arbitrary1,
  Arbitrary<T2> arbitrary2,
  Arbitrary<T3> arbitrary3,
  Arbitrary<T4> arbitrary4,
  Arbitrary<T5> arbitrary5,
  Arbitrary<T6> arbitrary6,
  Arbitrary<T7> arbitrary7, {
  required void Function(State, T1, T2, T3, T4, T5, T6, T7) nextState,
  required R Function(System, T1, T2, T3, T4, T5, T6, T7) run,
  bool Function(State, T1, T2, T3, T4, T5, T6, T7)? precondition,
  bool Function(State, T1, T2, T3, T4, T5, T6, T7, R)? postcondition,
}) : super(
        description,
        combine7(
          arbitrary1,
          arbitrary2,
          arbitrary3,
          arbitrary4,
          arbitrary5,
          arbitrary6,
          arbitrary7,
          (a, b, c, d, e, f, g) => (a, b, c, d, e, f, g),
        ),
        nextState: (s, args) => nextState(
          s,
          args.$1,
          args.$2,
          args.$3,
          args.$4,
          args.$5,
          args.$6,
          args.$7,
        ),
        run: (sys, args) => run(
          sys,
          args.$1,
          args.$2,
          args.$3,
          args.$4,
          args.$5,
          args.$6,
          args.$7,
        ),
        precondition: (s, args) =>
            precondition?.call(
              s,
              args.$1,
              args.$2,
              args.$3,
              args.$4,
              args.$5,
              args.$6,
              args.$7,
            ) ??
            true,
        postcondition: (s, args, r) =>
            postcondition?.call(
              s,
              args.$1,
              args.$2,
              args.$3,
              args.$4,
              args.$5,
              args.$6,
              args.$7,
              r,
            ) ??
            true,
      );