interface CashBoxAccounts {
    class AccountAlreadyExists extends RuntimeException {
        private UUID accountId;

        public AccountAlreadyExists(UUID accountId) {

            this.accountId = accountId;
        }

        @Override
        public String toString() {
            return String.format("Account already exists for %s.",
                                 accountId);
        }
    }

    class AccountDoesNotExist extends RuntimeException {
        private UUID accountId;

        public AccountDoesNotExist(UUID accountId) {

            this.accountId = accountId;
        }

        @Override
        public String toString() {
            return String.format("Account does not exist for %s.",
                                 accountId);
        }
    }

    class InsufficientFunds extends RuntimeException {
        private UUID accountId;
        private int requestedAmount;
        private int currentBalance;

        public InsufficientFunds(UUID accountId, int requestedAmount,
                                 int currentBalance) {
            this.accountId = accountId;
            this.requestedAmount = requestedAmount;
            this.currentBalance = currentBalance;
        }

        @Override
        public String toString() {
            return String.format(
                    "Insufficient funds in account %s for requested" +
                    " amount: %s. Current balance is: %s.",
                    accountId,
                    requestedAmount,
                    currentBalance);
        }
    }

    /**
     * Opens an account.
     * @throws {@link CashBoxAccounts.AccountAlreadyExists} if there is
     * an existing account using {@code accountId}.
     * @apiNote {@code cash} must be positive.
     */
    void open(UUID accountId, int cash) throws AccountAlreadyExists;

    /**
     * Deposit cash in an account.
     * @throws {@link CashBoxAccounts.AccountDoesNotExist} if there is
     * no existing account using {@code accountId}.
     * @apiNote {@code cash} must be positive.
     */
    void deposit(UUID accountId, int cash) throws AccountDoesNotExist;

    /**
     * Attempt to withdraw cash from an account.
     * @throws InsufficientFunds if the current balance does not cover
     * {@code requestedAmount}.
     * @throws {@link CashBoxAccounts.AccountDoesNotExist} if there is
     * no existing account using {@code accountId}.
     * @apiNote {@code requestedAmount} must be positive.
     */
    void withdraw(UUID accountId, int requestedAmount)
            throws AccountDoesNotExist, InsufficientFunds;

    /**
     * Closes the account, forgetting {@code accountId}
     * @param accountId
     * @throws {@link CashBoxAccounts.AccountDoesNotExist} if there is
     * no existing account using {@code accountId}.
     * @return The final balance.
     */
    int close(UUID accountId) throws AccountDoesNotExist;
}

public class Bank {
    private final Map<UUID, Integer> accountBalances = new HashMap<>();

    /**
     * Execute a transaction, supplying a {@link CashBoxAccounts} that
     * is valid for the duration of the transaction.
     * @apiNote Commits the effects made on the {@link CashBoxAccounts}
     * on successful completion of {@code action}. Any exception thrown
     * by {@code action} rolls the effects back.
     * @implNote Accounts may earn interest and log a transaction
     * history, so the implementation should have some notion of time to
     * mark the effects of a transaction. This is presumably UTC.
     * @param action
     */
    public void transaction(Consumer<CashBoxAccounts> action) {
        final CashBoxAccounts cashBoxAccounts =
                new CashBoxAccounts() {
                    @Override
                    public void open(UUID accountId, int cash)
                            throws AccountAlreadyExists {
                        Preconditions.checkArgument(0 < cash);
                        if (null !=
                            accountBalances.putIfAbsent(accountId, cash)) {
                            throw new AccountAlreadyExists(accountId);
                        }
                    }

                    @Override
                    public void deposit(UUID accountId, int cash)
                            throws AccountDoesNotExist {
                        Preconditions.checkArgument(0 < cash);
                        if (null == accountBalances.computeIfPresent(
                                accountId,
                                (unused, balance) -> cash + balance)) {
                            throw new AccountDoesNotExist(accountId);
                        }
                    }

                    @Override
                    public void withdraw(UUID accountId,
                                         int requestedAmount)
                            throws InsufficientFunds, AccountDoesNotExist {
                        Preconditions.checkArgument(0 < requestedAmount);
                        if (null == accountBalances.computeIfPresent(
                                accountId,
                                (unused, balance) -> {
                                    if (requestedAmount <= balance) {
                                        return balance - requestedAmount;
                                    } else throw new InsufficientFunds(
                                            accountId,
                                            requestedAmount,
                                            balance);
                                })) {
                            throw new AccountDoesNotExist(accountId);
                        }
                    }

                    @Override
                    public int close(UUID accountId)
                            throws AccountDoesNotExist {
                        return Optional
                                .of(accountBalances.get(accountId))
                                .orElseThrow(() -> new AccountDoesNotExist(
                                        accountId));
                    }
                };

        action.accept(cashBoxAccounts);
    }
}

class TestPlan {
    TestPlan(UUID accountId, int availableToDeposit,
             int targetToWithdraw, Step step) {
        this.accountId = accountId;
        this.availableToDeposit = availableToDeposit;
        this.targetToWithdraw = targetToWithdraw;
        this.step = step;
    }

    static class Step {
        final Consumer<CashBoxAccounts> action;
        final Optional<Step> followingStep;

        Step(Consumer<CashBoxAccounts> action,
             Optional<TestPlan.Step> followingStep) {
            this.action = action;
            this.followingStep = followingStep;
        }

        void executeUsing(Bank bank) {
            bank.transaction(action);

            // This is costly in terms of stack space, but is only test
            // code, so....
            followingStep.ifPresent(value -> value.executeUsing(bank));
        }
    }

    private Step followingStep(Consumer<CashBoxAccounts> action) {
        return new Step(action, Optional.of(step));
    }

    private final UUID accountId;

    private final int availableToDeposit;

    private final int targetToWithdraw;

    private final Step step;

    public static TestPlan closure(UUID accountId,
                                   int lumpSum,
                                   int expectedFinalBalance) {
        Preconditions.checkArgument(expectedFinalBalance <= lumpSum);

        return new TestPlan(accountId,
                            lumpSum,
                            lumpSum - expectedFinalBalance,
                            new Step(cashBoxAccounts -> {
                                final int closingBalance =
                                        cashBoxAccounts.close(accountId);
                                assertThat(closingBalance,
                                           greaterThanOrEqualTo(
                                                   expectedFinalBalance));
                                System.out.format(
                                        "Closed and validated," +
                                        " expected final balance is %d," +
                                        " closing balance is: %d.\n",
                                        expectedFinalBalance,
                                        closingBalance);
                            }, Optional.empty()));
    }

    public TestPlan deposition(int cash) {
        Preconditions.checkArgument(1 <= availableToDeposit);

        return new TestPlan(accountId,
                            availableToDeposit - cash,
                            targetToWithdraw,
                            followingStep(cashBoxAccounts -> {
                                cashBoxAccounts.deposit(accountId, cash);
                                System.out.println("Deposited.");
                            }));
    }

    public TestPlan withdrawal(int requestedAmount) {
        Preconditions.checkArgument(1 <= targetToWithdraw);

        return new TestPlan(accountId,
                            availableToDeposit,
                            targetToWithdraw - requestedAmount,
                            followingStep(cashBoxAccounts -> {
                                cashBoxAccounts.withdraw(accountId,
                                                         requestedAmount);
                                System.out.println("Withdrawn.");
                            }));
    }

    public TestPlan opening() {
        Preconditions.checkArgument(0 == targetToWithdraw);

        return new TestPlan(accountId,
                            0,
                            0,
                            followingStep(cashBoxAccounts -> {
                                cashBoxAccounts.open(accountId,
                                                     availableToDeposit);
                                System.out.println("Opened.");
                            }));
    }

    public Trials<TestPlan> extend() {
        if (0 == targetToWithdraw) {
            return api().only(opening());
        }

        final List<Trials<TestPlan>> choices =
                new LinkedList();

        if (2 <= availableToDeposit) {
            choices.add(api().integers(1, availableToDeposit - 1)
                             .map(this::deposition));
        }

        if (1 <= targetToWithdraw) {
            choices.add(api().integers(1, targetToWithdraw)
                             .map(this::withdrawal));
        }

        return api()
                .alternate(choices)
                .flatMap(plan -> plan.extend());
    }

    public void executeUsing(Bank bank) {
        step.executeUsing(bank);
    }
}


final Trials<TestPlan> testPlans = api()
        .integers(1, 1000)
        .flatMap(lumpSum -> api()
                .integers(1, lumpSum)
                .flatMap(expectedFinalBalance -> TestPlan
                        .closure(UUID.randomUUID(),
                                 lumpSum,
                                 expectedFinalBalance)
                        .extend()));

try {
    testPlans.withLimit(10).supplyTo(testPlan -> {
        try {
            testPlan.executeUsing(new Bank());
        } catch (Throwable t) {
            System.out.println(t);
            throw t;
        }
    });
} catch (TrialsFactoring.TrialException exception) {
    System.out.println(exception);
}

try {
    testPlans.withLimit(10).supplyTo(testPlan -> {
        try {
            testPlan.executeUsing(new Bank());
        } catch (CashBoxAccounts.InsufficientFunds e) {
            Trials.reject();
        } catch (Throwable t) {
            System.out.println(t);
            throw t;
        }
    });
} catch (TrialsFactoring.TrialException exception) {
    System.out.println(exception);
}

Test.whenever(<some Boolean guard precondition>, () -> {<block of guarded test code>});