Interface AroundTryHook

  • All Superinterfaces:
    Functional Interface:
    This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

    public interface AroundTryHook
    extends LifecycleHook
    Implement this hook to define behaviour that should "wrap" the execution of a single try, i.e., do something directly before or after executing a property method with a given list of parameters. You can even change the result of a try from satisfied to falsified or the other way round.
    • Method Detail

      • aroundTry

        TryExecutionResult aroundTry​(TryLifecycleContext context,
                                     TryExecutor aTry,
                                     java.util.List<java.lang.Object> parameters)
                              throws java.lang.Throwable
        When you wrap a try you can do stuff before and/or after its execution. All implementors should invoke the try with aTry.execute(parameters) and either return the result of this call or create another result.

        It is possible to manipulate the parameters before invoking aTry.execute(parameters). Never change the number and types of parameters because this will result in runtime errors. Also keep in mind that all manipulation might mess up random generation and shrinking.

        context - The property's context object
        aTry - executor to call
        parameters - the generated parameters for this try
        result of running a single try
      • aroundTryProximity

        default int aroundTryProximity()
        The higher the value, the closer to the actual property method. Default value is 0.

        Values greater than -10 will make it run "inside" annotated lifecycle methods (BeforeTry and AfterTry).

        an integer value
      • compareTo

        default int compareTo​(AroundTryHook other)