@Test
void separateMethods() {
  step(user_is_authorized_as("user1", "123456")
    .withName("user authorized as simple user"));
  step(user_sees_balance(10000)
    .withComment("user1 balance is always 10000"));
  step(user_sees_logout_button());
}
@Test
void aroundContext() {
  around(
    step(I_send_get_user_request(123))
      .withBefore(() -> AuthUtils.checkAuth())).
    step(response_status_code_should_be(200)).
    step(response_json_path_value_should_be("user.balance", 10000)
      .withName("response user balance should be {value}")
      .withOnFailure(response -> Logger.warn("Incorrect body: " + response.body())));
}

@Test
void separateMethods() {
  When(user_is_authorized_as("user1", "123456")
    .withName("user authorized as simple user"));
  Then(user_sees_balance(10000)
    .withComment("user1 balance is always 10000"));
  And(user_sees_logout_button());
}
@Test
void aroundContext() {
  around(
    When(I_send_get_user_request(123)
      .withBefore(() -> AuthUtils.checkAuth()))).
    Then(response_status_code_should_be(200)).
    And(response_json_path_value_should_be("user.balance", 10000)
      .withName("response user balance should be {value}")
      .withOnFailure(response -> Logger.warn("Incorrect body: " + response.body())));
}

@Test
void separateMethods() {
  Act(user_is_authorized_as("user1", "123456")
    .withName("user authorized as simple user"));
  Assert(user_sees_balance(10000)
    .withComment("user1 balance is always 10000"));
  Assert(user_sees_logout_button());
}
@Test
void aroundContext() {
  around(
    Act(I_send_get_user_request(123)
      .withBefore(() -> AuthUtils.checkAuth()))).
    Assert(response_status_code_should_be(200)).
    Assert(response_json_path_value_should_be("user.balance", 10000)
      .withName("response user balance should be {value}")
      .withOnFailure(response -> Logger.warn("Incorrect body: " + response.body())));
}

public static RunnableStep user_is_authorized_as(String username,
                                                 String password) { return stepOf(
  "user is authorized as {username}", params("username", username, "password", password), () -> {
    // step body
  }
); }

@WithName("user is authorized as {username}")
@WithParams
public static RunnableStep user_is_authorized_as(String username,
                                                 String password) { return stepOf(() -> {
  // step body
}); }

import static org.stebz.step.executable.RunnableStep.notImplemented;
class ExampleTest {
  
  @Test
  @Disabled // not implemented
  void manuallyDisabledTest() {
    Given("Step 1", "Expected result 1");
    When("Step 2", "Expected result 2");
    Then("Step 3", "Expected result 3");
  }
  @Test
  void throwingErrorTest() {
    Given(notImplemented()
      .withName("Step 1")
      .withExpectedResult("Expected result 1"));
    When(notImplemented()
      .withName("Step 2")
      .withExpectedResult("Expected result 2"));
    Then(notImplemented()
      .withName("Step 3")
      .withExpectedResult("Expected result 3"));
  }
}

RunnableStep runnableStep = RunnableStep.of("runnable step", () -> {
  // step body
});
SupplierStep<String> supplierStep = SupplierStep.of("supplier step", () -> {
  // step body
  return "result";
});
ConsumerStep<Integer> consumerStep = ConsumerStep.of("consumer step", integer -> {
  // step body
});
FunctionStep<Integer, String> functionStep = FunctionStep.of("function step", integer -> {
  // step body
  return "result";
});

RunnableStep newStep = step
  .withName("new name")
  .withBody(() -> {
    // new body
  });

RunnableStep newStep = step
  .withName(name -> "name prefix " + name)
  .withBodyOf(originBody -> () -> {
    // new body
    originBody.run();
  });

step(runnableStep);
String supplierStepResult = step(supplierStep);
step(consumerStep, 123);
String functionStepResult = step(functionStep, 123);

String result = around(123)
  .step(runnableStep)
  .step(supplierStep.noResult())
  .step(consumerStep)
  .step(functionStep);

step(runnableStep
  .withName("new name")
  .withExpectedResult("expected result")
  .withComment("comment")
  .withBefore(() -> Logger.info("..."))
  .withOnSuccess(() -> Logger.info("..."))
  .withOnFailure(() -> Logger.warn("...")));

step("quick runnable step", "expected result", () -> {
  // step body
});
String result = step("quick supplier step", params("param1", "value1"), () -> {
  // step body
  return "result";
});

StepAttribute<String> customAttribute = StepAttribute.nonNull("custom_attribute", "");
RunnableStep stepWithCustomAttribute = step.with(customAttribute, "attribute value");
String attributeValue = stepWithCustomAttribute.get(customAttribute);

@WithName("step name")
@WithComment("step comment")
@WithParam(name = "custom param", value = "custom param value")
public static final RunnableStep fieldStep = stepOf(() -> {
  // step body
});
@WithName("step name")
@WithComment("step comment")
@WithParams
@WithParam(name = "custom param", value = "custom param value")
public static RunnableStep methodStep(String parameter) { return stepOf(() -> {
  // step body
}); }
public class StepImpl extends RunnableStep.Of {
  @WithName("step name")
  @WithComment("step comment")
  @WithParams
  @WithParam(name = "custom param", value = "custom param value")
  public StepImpl(String parameter) { super(() -> {
    // step body
  }); }
}

@WithName("step name")
@WithComment("step comment")
@WithParams
@WithParam(name = "custom param", value = "custom param value")
public static void method(String parameter) {
  // step body
}
public class MyObject {
  @WithName("step name")
  @WithComment("step comment")
  @WithParams
  @WithParam(name = "custom param", value = "custom param value")
  public MyObject(String parameter) {
    // step body
  }
}

RunnableStep runnableStep = captured(MyClass::method, "arg");
SupplierStep<MyObject> supplierStep = captured(MyObject::new, "arg");

RunnableStep runnableStep = captured(() -> MyClass.method("arg"));
SupplierStep<MyObject> supplierStep = captured(() -> new MyObject("arg"));

step(captured(MyClass::method, "arg")
  .withName("Custom name")
  .withComment("Custom comment"));

@Target({ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@StepAttributeAnnotation("custom_attribute")
public @interface CustomAttribute {
  String value();
}

StepAttribute<CustomAttribute> attribute = StepAttribute.nullable("custom_attribute");
CustomAttribute value = step.get(attribute);

Arrange(runnableStep);
Act(consumerStep, 123);
Assert("quick step", () -> {
  // step body
});
Assert("quick step", () -> {
  // step body
});

@Arrange("step name")
@WithExpectedResult("step expected result")
@WithComment("step comment")
public static RunnableStep methodStep(String parameter) { return RunnableStep.of(() -> {
  // step body
}); }
@Act("step name")
@WithParams
public static void quickStep(String parameter) {
  // step body
}

Given(runnableStep);
When(consumerStep, 123);
Then("quick step", () -> {
  // step body
});
And("quick step", () -> {
  // step body
});

@Given("step name")
@WithExpectedResult("step expected result")
@WithComment("step comment")
public static RunnableStep methodStep(String parameter) { return RunnableStep.of(() -> {
  // step body
}); }
@When("step name")
@WithParams
public static void quickStep(String parameter) {
  // step body
}

@Test
@Disabled
void simpleSteps() {
  step("user authorized as user1");
  step("user sees balance 10000");
  step("user sees logout button");
}
@Test
@Disabled
void aaaSteps() {
  Act("user authorized as user1");
  Assert("user sees balance 10000");
  Assert("user sees logout button");
}
@Test
@Disabled
void gherkinSteps() {
  When("user authorized as user1");
  Then("user sees balance 10000");
  And("user sees logout button");
}

step("user authorized as simple user",
  params("username", "user1", "password", "12345"),
  "the authorization form is hidden, the user sees the header");

import static org.stebz.step.executable.RunnableStep.notImplemented;
class ExampleTest {
  @Test
  void test() {
    Given(notImplemented()
      .withName("Step 1")
      .withExpectedResult("Expected result 1"));
    When(notImplemented()
      .withName("Step 2")
      .withExpectedResult("Expected result 2"));
    Then(notImplemented()
      .withName("Step 3")
      .withExpectedResult("Expected result 3"));
  }
}

public interface StepListener {
  void onStepStart(StepObj<?> step,
                   NullableOptional<Object> context);
  void onStepSuccess(StepObj<?> step,
                     NullableOptional<Object> context,
                     NullableOptional<Object> result);
  void onStepFailure(StepObj<?> step,
                     NullableOptional<Object> context,
                     Throwable exception);
}

public interface InterceptStepException extends StebzExtension {
  Throwable interceptStepException(StepObj<?> step,
                                   NullableOptional<Object> context,
                                   Throwable exception);
}

public interface BeforeStepFailure extends StebzExtension {
  void beforeStepFailure(StepObj<?> step,
                         NullableOptional<Object> context,
                         Throwable exception);
}

class ExampleTest {
  @Test
  void test() {
    step("Step 1", () -> {
      step("Step 2", () -> {
        step("Step 3", () -> {
          throw new AssertionError();
        });
      });
    });
  }
}

hiddenSteps(() -> {
  step("Step 1");
  step("Step 2");
  step("Step 3");
});

@Step
public static RunnableStep user_is_authorized(String username,
                                              String password) { return RunnableStep.of(() -> {
  // step body
}); }

@Step
@NameWordSeparator("__")
public static RunnableStep user__is__authorized(String username,
                                                String password) { return RunnableStep.of(() -> {
  // step body
}); }

@Step
@WithRetry(count = 3, on = TimeoutException.class)
public static RunnableStep send_unstable_request() { return RunnableStep.of(() -> {
  // step body
}); }
@Step
@WithRepeat(count = 3)
public static RunnableStep send_request_multiple_times() { return RunnableStep.of(() -> {
  // step body
}); }

step(send_request()
  .with(retry, retry().count(3).on(TimeoutException.class)));
step(send_request()
  .with(repeat, repeat().count(3)));