Chapter 11 Companion: Code, Explanations and Solutions

mvn --batch-mode verify
java -cp target/classes edu.se506.lending.bootstrap.Chapter11Demo

OVERDUE REPORT 2026-10-20
CAM1 B1 10 day(s) late, fine 4.00
MIC1 B2 8 day(s) late, fine 0.75
LAP1 B4 2 day(s) late, fine 0.00
3 overdue, total fines 4.75

cp stages/stage2/OverdueReport.java src/main/java/legacy/OverdueReport.java
mvn --batch-mode -Dtest='OverdueReport*Test' test

mkdir -p probe/out
javac --release 17 -d probe/out src/main/java/legacy/*.java probe/OriginalUnseamed.java probe/OriginalReportProbe.java
java -cp probe/out legacy.OriginalReportProbe

package legacy;

import java.time.LocalDate;

/**
 * One row exported by the old records system. Public mutable fields are the
 * old system's format and other programs read them, so this class stays as it is.
 */
public class LoanRow {
    public String item;
    public String borrower;
    /** "S" for a student, "T" for a staff member, as in the old directory. */
    public String kind;
    public LocalDate due;
    public boolean returned;

    public LoanRow(String item, String borrower, String kind, LocalDate due, boolean returned) {
        this.item = item;
        this.borrower = borrower;
        this.kind = kind;
        this.due = due;
        this.returned = returned;
    }
}

package legacy;

/** How a fine grows: free days, a daily rate, and the most one loan can cost. */
record FinePolicy(int graceDays, double ratePerDay, double cap) {

    double fineFor(long daysLate) {
        if (daysLate <= graceDays) {
            return 0;
        }
        return Math.min((daysLate - graceDays) * ratePerDay, cap);
    }
}

package legacy;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.List;

/** Lists the unreturned loans that are past their due date, with the fine for each. */
public class OverdueReport {
    private static final FinePolicy STUDENT = new FinePolicy(2, 0.50, 10.00);
    private static final FinePolicy STAFF = new FinePolicy(5, 0.25, 5.00);
    /**
     * Suspected defect, preserved on purpose: any other kind pays 1.00 a day with no grace and no cap.
     * Change it only in a separate, agreed functional change (see the chapter, Section 11.7).
     */
    private static final FinePolicy ANY_OTHER_KIND = new FinePolicy(0, 1.00, Double.MAX_VALUE);

    public static String build(List<LoanRow> rows) {
        return build(rows, LocalDate.now());
    }

    public static String build(List<LoanRow> rows, LocalDate today) {
        StringBuilder report = new StringBuilder("OVERDUE REPORT " + today + "\n");
        double totalFines = 0;
        int overdueCount = 0;
        for (LoanRow row : rows) {
            if (row.returned) {
                continue;
            }
            long daysLate = ChronoUnit.DAYS.between(row.due, today);
            if (daysLate > 0) {
                double fine = policyFor(row.kind).fineFor(daysLate);
                report.append(row.item).append(' ').append(row.borrower).append(' ')
                        .append(daysLate).append(" day(s) late, fine ").append(money(fine)).append('\n');
                totalFines += fine;
                overdueCount++;
            }
        }
        report.append(overdueCount).append(" overdue, total fines ").append(money(totalFines)).append('\n');
        return report.toString();
    }

    public static void print(List<LoanRow> rows) {
        System.out.print(build(rows));
    }

    private static FinePolicy policyFor(String kind) {
        if (kind.equals("S")) {
            return STUDENT;
        }
        if (kind.equals("T")) {
            return STAFF;
        }
        return ANY_OTHER_KIND;
    }

    private static String money(double amount) {
        return String.format("%.2f", amount);
    }
}

package edu.se506.lending.bootstrap;

import java.time.LocalDate;
import java.util.List;
import legacy.LoanRow;
import legacy.OverdueReport;

/** Prints the legacy overdue report for a fixed date. The legacy package stays outside the lending layers. */
public final class Chapter11Demo {
    public static void main(String[] args) {
        LocalDate today = LocalDate.of(2026, 10, 20);
        List<LoanRow> rows = List.of(
                new LoanRow("CAM1", "B1", "S", today.minusDays(10), false),
                new LoanRow("MIC1", "B2", "T", today.minusDays(8), false),
                new LoanRow("TRI1", "B3", "S", today.minusDays(1), true),
                new LoanRow("LAP1", "B4", "S", today.minusDays(2), false));
        System.out.print(OverdueReport.build(rows, today));
    }
}

package edu.se506.lending.bootstrap;

import java.util.List;
import legacy.LoanRow;

/** One complete, non-null snapshot of rows for the legacy report. A failure must propagate. */
@FunctionalInterface
public interface OverdueRowSource {
    List<LoanRow> rows();
}

package edu.se506.lending.bootstrap;

import java.time.Clock;
import java.time.LocalDate;
import java.util.List;
import java.util.Objects;
import legacy.LoanRow;
import legacy.OverdueReport;

/**
 * Runs the legacy report against the live lending data. It reads one date and one snapshot per
 * call and changes nothing in the lending state. It lives in bootstrap, the only code that may
 * know both the lending layers and the isolated legacy package.
 */
public final class OverdueReportService {
    private final OverdueRowSource source;
    private final Clock clock;

    public OverdueReportService(OverdueRowSource source, Clock clock) {
        this.source = Objects.requireNonNull(source, "source");
        this.clock = Objects.requireNonNull(clock, "clock");
    }

    public String report() {
        LocalDate today = LocalDate.now(clock);
        List<LoanRow> rows = Objects.requireNonNull(source.rows(), "rows");
        return OverdueReport.build(rows, today);
    }
}

package edu.se506.lending.bootstrap;

import edu.se506.lending.domain.Loan;
import edu.se506.lending.domain.Reservation;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import legacy.LoanRow;

/**
 * Feeds the legacy report from the lending snapshots. A reservation covers a half-open period, so
 * the last permitted day is the day before its exclusive end. Reads two snapshots one after the
 * other (sequential use only, not an atomic read).
 */
public final class LoanSnapshotRows implements OverdueRowSource {
    private final Supplier<List<Loan>> loans;
    private final Supplier<List<Reservation>> reservations;
    private final Function<String, String> kindOf;

    public LoanSnapshotRows(Supplier<List<Loan>> loans, Supplier<List<Reservation>> reservations,
                            Function<String, String> kindOf) {
        this.loans = Objects.requireNonNull(loans, "loans");
        this.reservations = Objects.requireNonNull(reservations, "reservations");
        this.kindOf = Objects.requireNonNull(kindOf, "kindOf");
    }

    @Override public List<LoanRow> rows() {
        List<Loan> loanSnapshot = List.copyOf(loans.get());
        List<Reservation> reservationSnapshot = List.copyOf(reservations.get());
        List<LoanRow> rows = new ArrayList<>();
        for (Loan loan : loanSnapshot) {
            Reservation reservation = reservationSnapshot.stream()
                    .filter(r -> r.id().equals(loan.reservationId())).findFirst()
                    .orElseThrow(() -> new IllegalStateException(
                            "Missing reservation for loan: " + loan.reservationId()));
            if (!reservation.borrowerId().equals(loan.borrowerId())
                    || !reservation.itemId().equals(loan.itemId())) {
                throw new IllegalStateException("Mismatched loan: " + loan.reservationId());
            }
            String kind = kindOf.apply(loan.borrowerId());
            if (kind == null) {
                throw new IllegalStateException("No kind for borrower: " + loan.borrowerId());
            }
            rows.add(new LoanRow(loan.itemId(), loan.borrowerId(), kind,
                    reservation.period().endExclusive().minusDays(1), !loan.active()));
        }
        return List.copyOf(rows);
    }
}

import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Prints afferent coupling (Ca), efferent coupling (Ce) and instability
 * I = Ce / (Ca + Ce) for each package of the compiled production classes.
 *
 * Counting unit: classes. Nested classes count with their outer class. Only
 * dependencies between this project's own packages are counted; the standard
 * library is ignored. When Ca + Ce is 0 the instability is undefined.
 *
 * Run from the project root after "mvn compile":
 *   java tools/PackageMetrics.java target/classes
 */
public final class PackageMetrics {
    private static final Pattern EDGE =
            Pattern.compile("(?m)^\\s+([\\w.$]+)\\s+->\\s+([\\w.$]+)\\s+\\S+\\s*$");

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println("usage: java tools/PackageMetrics.java <classes directory>");
            System.exit(2);
        }
        String executable = System.getProperty("os.name").toLowerCase().contains("win") ? "java.exe" : "java";
        String java = Path.of(System.getProperty("java.home"), "bin", executable).toString();
        Process process = new ProcessBuilder(java, "--module", "jdk.jdeps/com.sun.tools.jdeps.Main",
                "-verbose:class", "-filter:none", Path.of(args[0]).toAbsolutePath().toString())
                .redirectErrorStream(true).start();
        String output = new String(process.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
        if (process.waitFor() != 0) {
            System.err.println(output);
            System.exit(1);
        }

        Map<String, Set<String>> classesIn = new TreeMap<>();
        Map<String, Set<String>> dependersOutside = new TreeMap<>();   // classes outside P that use P
        Map<String, Set<String>> dependersInside = new TreeMap<>();    // classes in P that use outside classes
        Matcher m = EDGE.matcher(output);
        while (m.find()) {
            String from = outer(m.group(1));
            String to = outer(m.group(2));
            if (!local(from)) continue;
            classesIn.computeIfAbsent(pkg(from), k -> new TreeSet<>()).add(from);
            if (!local(to)) continue;
            classesIn.computeIfAbsent(pkg(to), k -> new TreeSet<>()).add(to);
            if (!pkg(from).equals(pkg(to))) {
                dependersOutside.computeIfAbsent(pkg(to), k -> new TreeSet<>()).add(from);
                dependersInside.computeIfAbsent(pkg(from), k -> new TreeSet<>()).add(from);
            }
        }
        System.out.printf("%-48s %7s %4s %4s %9s%n", "package", "classes", "Ca", "Ce", "I");
        for (String p : classesIn.keySet()) {
            int ca = dependersOutside.getOrDefault(p, Set.of()).size();
            int ce = dependersInside.getOrDefault(p, Set.of()).size();
            String instability = ca + ce == 0 ? "undefined" : String.format("%.2f", ce / (double) (ca + ce));
            System.out.printf("%-48s %7d %4d %4d %9s%n", p, classesIn.get(p).size(), ca, ce, instability);
        }
    }

    private static boolean local(String type) {
        return type.startsWith("edu.se506.") || type.startsWith("patterns.")
                || type.startsWith("behaviour.") || type.startsWith("examples.")
                || type.startsWith("legacy.");
    }

    private static String outer(String type) {
        int dollar = type.indexOf('$');
        return dollar < 0 ? type : type.substring(0, dollar);
    }

    private static String pkg(String type) {
        return type.substring(0, type.lastIndexOf('.'));
    }
}

package legacy;

import static org.junit.jupiter.api.Assertions.*;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.nio.charset.StandardCharsets;
import java.time.Clock;
import java.time.Instant;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.util.List;
import java.util.Locale;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

/**
 * Characterisation tests: they record what the report does today, including behaviour
 * that looks wrong. A passing test here means "unchanged", not "correct".
 */
class OverdueReportCharacterisationTest {
    private static final LocalDate TODAY = LocalDate.of(2026, 10, 20);
    private static final String HEADER = "OVERDUE REPORT 2026-10-20\n";

    private Locale savedLocale;

    @BeforeEach void pinTheLocale() {
        savedLocale = Locale.getDefault();
        Locale.setDefault(Locale.ROOT);
    }

    @AfterEach void restoreTheLocale() {
        Locale.setDefault(savedLocale);
    }

    private static LoanRow open(String kind, int daysLate) {
        return new LoanRow("CAM1", "B1", kind, TODAY.minusDays(daysLate), false);
    }

    private static String oneLoan(int daysLate, String fine) {
        return HEADER + "CAM1 B1 " + daysLate + " day(s) late, fine " + fine + "\n"
                + "1 overdue, total fines " + fine + "\n";
    }

    // Observed fines for students (2 days of grace, 0.50 a day, capped at 10.00)
    // and staff (5 days of grace, 0.25 a day, capped at 5.00).
    @ParameterizedTest
    @CsvSource({
            "S,1,0.00", "S,2,0.00", "S,3,0.50", "S,10,4.00", "S,22,10.00", "S,23,10.00", "S,100,10.00",
            "T,1,0.00", "T,5,0.00", "T,6,0.25", "T,25,5.00", "T,26,5.00", "T,100,5.00"})
    void finesForStudentsAndStaff(String kind, int daysLate, String fine) {
        assertEquals(oneLoan(daysLate, fine), OverdueReport.build(List.of(open(kind, daysLate)), TODAY));
    }

    // SUSPECTED DEFECT, pinned on purpose: any other kind pays 1.00 a day with no grace and no cap.
    @ParameterizedTest
    @CsvSource({"X,1,1.00", "X,100,100.00", "s,3,3.00"})
    void otherKindsPayTheFullRateWithNoGraceOrCap(String kind, int daysLate, String fine) {
        assertEquals(oneLoan(daysLate, fine), OverdueReport.build(List.of(open(kind, daysLate)), TODAY));
    }

    @Test void aBlankKindIsTreatedLikeAnyOtherKind() {
        assertEquals(oneLoan(2, "2.00"), OverdueReport.build(List.of(open("", 2)), TODAY));
    }

    @Test void loansWithinGraceAreStillListedAndCounted() {
        String report = OverdueReport.build(List.of(open("S", 1), open("T", 4)), TODAY);
        assertEquals(HEADER + "CAM1 B1 1 day(s) late, fine 0.00\n" + "CAM1 B1 4 day(s) late, fine 0.00\n"
                + "2 overdue, total fines 0.00\n", report);
    }

    @Test void loansDueTodayDueLaterOrReturnedAreNotListed() {
        List<LoanRow> rows = List.of(
                open("S", 0),
                new LoanRow("CAM1", "B1", "S", TODAY.plusDays(3), false),
                new LoanRow("CAM1", "B1", "S", TODAY.minusDays(30), true));
        assertEquals(HEADER + "0 overdue, total fines 0.00\n", OverdueReport.build(rows, TODAY));
    }

    @Test void aNullKindOnALoanThatIsReturnedOrNotYetDueIsIgnored() {
        List<LoanRow> rows = List.of(
                new LoanRow("CAM1", "B1", null, TODAY.minusDays(30), true),
                new LoanRow("CAM1", "B1", null, TODAY, false));
        assertEquals(HEADER + "0 overdue, total fines 0.00\n", OverdueReport.build(rows, TODAY));
    }

    @Test void anEmptyListGivesTheHeaderAndAZeroTotal() {
        assertEquals(HEADER + "0 overdue, total fines 0.00\n", OverdueReport.build(List.of(), TODAY));
    }

    @Test void rowsAreListedInInputOrderAndTheTotalAddsTheFines() {
        List<LoanRow> rows = List.of(
                new LoanRow("CAM1", "B1", "S", TODAY.minusDays(10), false),
                new LoanRow("MIC1", "B2", "T", TODAY.minusDays(8), false),
                new LoanRow("TRI1", "B3", "S", TODAY.minusDays(1), true),
                new LoanRow("LAP1", "B4", "S", TODAY.minusDays(2), false));
        assertEquals(HEADER
                + "CAM1 B1 10 day(s) late, fine 4.00\n"
                + "MIC1 B2 8 day(s) late, fine 0.75\n"
                + "LAP1 B4 2 day(s) late, fine 0.00\n"
                + "3 overdue, total fines 4.75\n", OverdueReport.build(rows, TODAY));
    }

    // Hidden dependency: the amounts are formatted in the JVM's default locale.
    // Whether a comma is wanted is a business question; today the report follows the locale.
    @Test void amountsFollowTheDefaultLocale() {
        Locale.setDefault(Locale.GERMANY);
        assertEquals(oneLoan(3, "0,50"), OverdueReport.build(List.of(open("S", 3)), TODAY));
    }

    @Test void aNullKindOrANullListFailsWithNullPointerException() {
        assertThrows(NullPointerException.class, () -> OverdueReport.build(List.of(open(null, 3)), TODAY));
        assertThrows(NullPointerException.class, () -> OverdueReport.build(null, TODAY));
    }

    // Hidden dependency: the entry point without a date reads the system clock.
    @Test void theShortEntryPointUsesTheSystemDate() {
        LocalDate before = LocalDate.now();
        String report = OverdueReport.build(List.of());
        LocalDate after = LocalDate.now();
        assertTrue(report.equals("OVERDUE REPORT " + before + "\n0 overdue, total fines 0.00\n")
                || report.equals("OVERDUE REPORT " + after + "\n0 overdue, total fines 0.00\n"), report);
    }

    // The seam moves the zone decision to the caller: one instant is two different calendar dates.
    @Test void theCallerChoosesTheZoneByChoosingTheDate() {
        Instant instant = Instant.parse("2026-10-21T22:30:00Z");
        LocalDate utcDate = LocalDate.now(Clock.fixed(instant, ZoneOffset.UTC));
        LocalDate baghdadDate = LocalDate.now(Clock.fixed(instant, ZoneId.of("Asia/Baghdad")));
        List<LoanRow> rows = List.of(new LoanRow("CAM1", "B1", "S", LocalDate.of(2026, 10, 21), false));
        assertEquals("OVERDUE REPORT 2026-10-21\n0 overdue, total fines 0.00\n", OverdueReport.build(rows, utcDate));
        assertEquals("OVERDUE REPORT 2026-10-22\nCAM1 B1 1 day(s) late, fine 0.00\n1 overdue, total fines 0.00\n",
                OverdueReport.build(rows, baghdadDate));
    }

    // Hidden dependency: print writes to System.out, which is global state.
    @Test void printWritesTheReportToStandardOutput() {
        PrintStream saved = System.out;
        ByteArrayOutputStream captured = new ByteArrayOutputStream();
        System.setOut(new PrintStream(captured, true, StandardCharsets.UTF_8));
        try {
            OverdueReport.print(List.of());
        } finally {
            System.setOut(saved);
        }
        String text = captured.toString(StandardCharsets.UTF_8);
        assertTrue(text.startsWith("OVERDUE REPORT ") && text.endsWith("0 overdue, total fines 0.00\n"), text);
    }
}

package legacy;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.List;

/**
 * Test-only oracle: the legacy report exactly as it was when the characterisation tests were written
 * (stage 1: the original plus the date parameter). Never edit this file; it is the reference answer.
 */
final class OriginalOverdueReport {

    public static String build(List<LoanRow> rows) {
        return build(rows, LocalDate.now());
    }

    public static String build(List<LoanRow> rows, LocalDate today) {
        String out = "";
        double total = 0;
        int count = 0;
        out += "OVERDUE REPORT " + today + "\n";
        for (int i = 0; i < rows.size(); i++) {
            LoanRow r = rows.get(i);
            if (r.returned) {
                continue;
            }
            long late = ChronoUnit.DAYS.between(r.due, today);
            if (late > 0) {
                double fine = 0;
                if (r.kind.equals("S")) {
                    if (late > 2) {
                        fine = (late - 2) * 0.50;
                        if (fine > 10) {
                            fine = 10;
                        }
                    }
                } else if (r.kind.equals("T")) {
                    if (late > 5) {
                        fine = (late - 5) * 0.25;
                        if (fine > 5) {
                            fine = 5;
                        }
                    }
                } else {
                    fine = 1.00 * late;
                }
                out += r.item + " " + r.borrower + " " + late + " day(s) late, fine "
                        + String.format("%.2f", fine) + "\n";
                total += fine;
                count++;
            }
        }
        out += count + " overdue, total fines " + String.format("%.2f", total) + "\n";
        return out;
    }

    public static void print(List<LoanRow> rows) {
        System.out.print(build(rows));
    }
}

package legacy;

import static org.junit.jupiter.api.Assertions.*;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import org.junit.jupiter.api.Test;

/**
 * A second safety net: the current report must give the same text as the original code for
 * thousands of generated inputs. It is stronger than a handful of examples, but it can only
 * compare behaviour for the kinds of input the generator produces.
 */
class OverdueReportDifferentialTest {
    private static final LocalDate TODAY = LocalDate.of(2026, 10, 20);
    private static final String[] KINDS = {"S", "T", "X", "s", ""};

    @Test void currentReportMatchesTheOriginalOnGeneratedInputs() {
        Locale saved = Locale.getDefault();
        Locale.setDefault(Locale.ROOT);
        try {
            Random random = new Random(11);
            for (int run = 0; run < 3000; run++) {
                List<LoanRow> rows = new ArrayList<>();
                int size = random.nextInt(7);
                for (int i = 0; i < size; i++) {
                    String kind = KINDS[random.nextInt(KINDS.length)];
                    LocalDate due = TODAY.minusDays(random.nextInt(70) - 5);
                    rows.add(new LoanRow("I" + random.nextInt(9), "B" + random.nextInt(9), kind, due, random.nextInt(5) == 0));
                }
                assertEquals(OriginalOverdueReport.build(rows, TODAY), OverdueReport.build(rows, TODAY),
                        "run " + run + " with " + size + " rows");
            }
        } finally {
            Locale.setDefault(saved);
        }
    }
}

package edu.se506.lending.structure;

import static org.junit.jupiter.api.Assertions.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.Path;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;

/** Checks compiled local dependency direction; not reflection or semantic correctness. */
class DependencyRulesTest {
    private static final String BASE = "edu.se506.lending.";
    private static final Pattern EDGE =
            Pattern.compile("(?m)^\\s*(edu\\.se506\\.lending\\.[\\w.$]+)\\s+->\\s+([\\w.$]+)\\s+.*$");

    @Test void compiledProductionDependenciesFollowDeclaredDirection() throws Exception {
        String output = jdepsOutput();
        var matcher = EDGE.matcher(output);
        int observed = 0;
        List<String> violations = new ArrayList<>();
        while (matcher.find()) {
            observed++;
            String from = matcher.group(1);
            String to = matcher.group(2);
            if (from.startsWith(BASE + "bootstrap.")) continue;
            if (to.startsWith("patterns.") || to.startsWith("behaviour.") || to.startsWith("examples.")
                    || to.startsWith("legacy.")) {
                violations.add(from + " -> " + to);
            } else if (to.startsWith(BASE) && !allowed(from, to)) {
                violations.add(from + " -> " + to);
            }
        }
        assertTrue(observed > 0, "jdeps must discover production class dependencies: " + output);
        assertTrue(violations.isEmpty(), String.join(System.lineSeparator(), violations));
    }

    @Test void productionPackagesHaveNoDependencyCycles() throws Exception {
        Map<String, Set<String>> graph = new TreeMap<>();
        var matcher = EDGE.matcher(jdepsOutput());
        while (matcher.find()) {
            String from = packageOf(matcher.group(1));
            String to = matcher.group(2).startsWith(BASE) ? packageOf(matcher.group(2)) : null;
            graph.computeIfAbsent(from, key -> new TreeSet<>());
            if (to != null && !to.equals(from)) graph.get(from).add(to);
        }
        assertTrue(graph.size() > 1, "jdeps must discover more than one production package");
        List<String> cycle = findCycle(graph);
        assertTrue(cycle.isEmpty(), "Package dependency cycle: " + String.join(" -> ", cycle));
    }

    private static String jdepsOutput() throws Exception {
        String executable = System.getProperty("os.name").toLowerCase().contains("win") ? "java.exe" : "java";
        String java = Path.of(System.getProperty("java.home"), "bin", executable).toString();
        Process process = new ProcessBuilder(java, "--module", "jdk.jdeps/com.sun.tools.jdeps.Main",
                "-verbose:class", "-filter:none", Path.of("target/classes").toAbsolutePath().toString())
                .redirectErrorStream(true).start();
        String output = new String(process.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
        assertEquals(0, process.waitFor(), output);
        return output;
    }

    private static String packageOf(String type) {
        String outer = type.contains("$") ? type.substring(0, type.indexOf('$')) : type;
        return outer.substring(0, outer.lastIndexOf('.'));
    }

    /** Depth-first search; returns the packages on one cycle, or an empty list. */
    private static List<String> findCycle(Map<String, Set<String>> graph) {
        Set<String> done = new HashSet<>();
        for (String start : graph.keySet()) {
            Deque<String> path = new ArrayDeque<>();
            List<String> found = visit(start, graph, path, done);
            if (!found.isEmpty()) return found;
        }
        return List.of();
    }

    private static List<String> visit(String node, Map<String, Set<String>> graph,
                                      Deque<String> path, Set<String> done) {
        if (path.contains(node)) {
            List<String> cycle = new ArrayList<>();
            boolean inCycle = false;
            for (String element : (Iterable<String>) path::descendingIterator) {
                if (element.equals(node)) inCycle = true;
                if (inCycle) cycle.add(element);
            }
            cycle.add(node);
            return cycle;
        }
        if (!done.add(node)) return List.of();
        path.push(node);
        for (String next : graph.getOrDefault(node, Set.of())) {
            List<String> found = visit(next, graph, path, done);
            if (!found.isEmpty()) return found;
        }
        path.pop();
        return List.of();
    }

    private boolean allowed(String from, String to) {
        if (from.startsWith(BASE + "domain.")) return to.startsWith(BASE + "domain.");
        if (from.startsWith(BASE + "application.port.")) {
            return to.startsWith(BASE + "application.port.") || to.startsWith(BASE + "domain.");
        }
        if (from.startsWith(BASE + "application.")) {
            return to.startsWith(BASE + "application.") || to.startsWith(BASE + "domain.");
        }
        if (from.startsWith(BASE + "infrastructure.")) {
            return to.startsWith(BASE + "infrastructure.") || to.startsWith(BASE + "application.")
                    || to.startsWith(BASE + "domain.");
        }
        if (from.startsWith(BASE + "presentation.")) {
            return to.startsWith(BASE + "presentation.") || to.startsWith(BASE + "application.")
                    || to.startsWith(BASE + "domain.");
        }
        return false;
    }
}