fix(schedule10): clear the remaining SonarCloud findings

Follow-up to the code review. Every reported item is fixed; none was dismissed as
a false positive.

DANGLING JAVADOC (Critical). PERCENTAGE_CONVERTER had been inserted between the
CONVERTER_KEYS_BY_TARGET javadoc and its field, orphaning the doc block. Both
converter constants now sit above it. VOLUME_CONVERTER is extracted at the same
time, which also covers the third usage in the type-fallback branch.

JOIN THESE MULTIPLE ASSERTIONS (8). Seven came from the previous commit's
containsEntry conversion, which left runs of consecutive single-entry assertions
on the same subject; they are now chained. The eighth, in
Schedule10CheckStatusIT, was missed by that pass because the seven assertions
there are separated by comments -- now one chain with each link's reasoning kept
beside it. No consecutive same-subject runs remain in any Schedule 10 test.

TEST THE EMPTINESS OF THE LIST (2 Bugs). doesNotContain(...) passes on an empty
list, so "End Haul is checked nowhere" and "method N skips the gated rules" would
both have passed even if the rule engine returned nothing at all. Each now
asserts isEmpty() -- the actual claim -- plus a CONTROL that proves the engine
ran: one drives an unrelated field out of range and expects exactly that field,
the other asserts the same empty stabilizing block under method C does produce
issues. Suppression is now demonstrably the gate rather than a dead rule set.

METHOD HAS 8 PARAMETERS. requireRange's bounds and format are bundled into a Band
record, taking it to six. The band(lower, format, upper) factory preserves the
legacy argument ORDER at all 30 call sites, so the rewrite was a pure textual
wrap and the reordering happens once inside the factory -- no chance of a silent
transposition changing a reported bound. The emission-order and bound-formatting
tests, which assert exact rendered bounds, pass unchanged.

CLASS HAS 6 PARENTS. InvalidBecClassificationException now extends
BusinessException directly. The subtype relationship bought nothing: nothing
catches either type, both map to 400, and the only thing it required was a
protected constructor on the parent existing solely to pass this class's message
key through. That constructor is removed as dead.

MONSTER CLASS (21 dependencies). Resolved in the previous commit by deleting the
persist(Runnable) overload, which became unreachable once every call site carried
a resource-specific message key.

While fixing the Critical dangling javadoc, the identical mistake was made in
Schedule10CheckStatus -- the new Band record landed between requireRange's
javadoc and its method. Checkstyle caught it along with two over-long lines from
the same edit.

Verification: 1151 unit + 881 integration tests, 0 failures; 0 checkstyle
violations in schedule10 under the newly bumped 13.10.0.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Rylan-cgi

backend/src/main/java/ca/bc/gov/nrs/ilcr/exception/GlobalExceptionHandler.java

@@ -258,7 +258,7 @@ public ResponseEntity<ProblemDetail> handleNotReadable(
     String key = converterKeyForField(causeMessage);
     if (key == null) {
       if (causeMessage.contains("java.math.BigDecimal")) {
-        key = "volumeConverterErrorMsg";
+        key = VOLUME_CONVERTER;
       } else if (causeMessage.contains("java.lang.Integer")
           || causeMessage.contains("java.lang.Long")) {
         key = "costConverterErrorMsg";
@@ -298,6 +298,12 @@ private static String converterKeyForField(String causeMessage) {
         .orElse(null);
   }
 
+  /** Shared by the five Schedule 10 material percentages, which all fail identically. */
+  private static final String PERCENTAGE_CONVERTER = "percentageConverterErrorMsg";
+
+  /** Shared by every volume field, Schedule 10's two haul volumes included. */
+  private static final String VOLUME_CONVERTER = "volumeConverterErrorMsg";
+
   /**
    * Converter message keys scoped to {@code DeclaringType["property"]}, matched against the
    * reference
@@ -320,9 +326,6 @@ private static String converterKeyForField(String causeMessage) {
    * collection
    * hops ({@code CulvertSaveAllRequest["culverts"]->…->CulvertRequest["spanSize"]}).
    */
-  /** Shared by all five Schedule 10 material percentages, which fail identically. */
-  private static final String PERCENTAGE_CONVERTER = "percentageConverterErrorMsg";
-
   private static final Map<String, String> CONVERTER_KEYS_BY_TARGET = Map.ofEntries(
       Map.entry("CulvertRequest[\"spanSize\"]", "culvertSpanConverterErrorMsg"),
       Map.entry("CulvertRequest[\"riseSize\"]", "culvertRiseConverterErrorMsg"),
@@ -331,8 +334,8 @@ private static String converterKeyForField(String causeMessage) {
       // detail — a percentage or a haul volume — fell through to the type default and told the
       // reporter their COST was invalid.
       Map.entry("RoadDetailRequest[\"sideSlopePct\"]", "sideSlopePercentageConverterErrorMsg"),
-      Map.entry("RoadDetailRequest[\"endHaulVolume\"]", "volumeConverterErrorMsg"),
-      Map.entry("RoadDetailRequest[\"overlandVolume\"]", "volumeConverterErrorMsg"),
+      Map.entry("RoadDetailRequest[\"endHaulVolume\"]", VOLUME_CONVERTER),
+      Map.entry("RoadDetailRequest[\"overlandVolume\"]", VOLUME_CONVERTER),
       Map.entry("MaterialCompositionRequest[\"solidRockPct\"]", PERCENTAGE_CONVERTER),
       Map.entry("MaterialCompositionRequest[\"rippableRockPct\"]", PERCENTAGE_CONVERTER),
       Map.entry("MaterialCompositionRequest[\"coarsePct\"]", PERCENTAGE_CONVERTER),

backend/src/main/java/ca/bc/gov/nrs/ilcr/schedule10/InvalidBecClassificationException.java

@@ -1,5 +1,8 @@
 package ca.bc.gov.nrs.ilcr.schedule10;
 
+import ca.bc.gov.nrs.ilcr.exception.BusinessException;
+import org.springframework.http.HttpStatus;
+
 /**
  * Raised when a road-detail write names a BEC classification the cross-reference does not offer, or
  * when that classification plus the RSMR class resolves to no moisture-code pair at all. Maps to
@@ -13,10 +16,17 @@
  * derived from this classification and the RSMR class, and both target columns are {@code NOT NULL}
  * with enabled foreign keys. Failing here with a clear 400 is the alternative to letting the insert
  * reach Oracle and return an opaque constraint violation.
+ *
+ * <p>Extends {@link BusinessException} directly rather than {@code
+ * InvalidClassificationCodeException}, even though a BEC code IS a kind of classification code. The
+ * subtype relationship bought nothing — nothing catches either type, both map to 400, and the only
+ * thing it required was a {@code protected} constructor on the parent existing solely to pass this
+ * class's message key through. It also pushed the inheritance depth to six. Flattened at code
+ * review follow-up 2026-08-18.
  */
-public class InvalidBecClassificationException extends InvalidClassificationCodeException {
+public class InvalidBecClassificationException extends BusinessException {
 
   public InvalidBecClassificationException() {
-    super("invalidBiogeoCode");
+    super(HttpStatus.BAD_REQUEST, "invalidBiogeoCode");
   }
 }

backend/src/main/java/ca/bc/gov/nrs/ilcr/schedule10/InvalidClassificationCodeException.java

@@ -20,14 +20,4 @@ public class InvalidClassificationCodeException extends BusinessException {
   public InvalidClassificationCodeException() {
     super(HttpStatus.BAD_REQUEST, "invalidCodeValueErrorMsg");
   }
-
-  /**
-   * For the BEC-classification case, which carries its own legacy message rather than the generic
-   * code-list one.
-   *
-   * @param messageKey the legacy bundle key to resolve
-   */
-  protected InvalidClassificationCodeException(String messageKey) {
-    super(HttpStatus.BAD_REQUEST, messageKey);
-  }
 }

backend/src/main/java/ca/bc/gov/nrs/ilcr/schedule10/Schedule10CheckStatus.java

@@ -196,76 +196,93 @@ static DetailOutcome evaluateRoadDetail(
     requirePresent(
         issues, "relSoilMoistRgmClsCode", prefix + " RSMR Class", detail.relSoilMoistRgmClsCode());
     requireRange(issues, "sideSlopePct", prefix + " Side Slope (%)",
-        value(detail.sideSlopePct()), ZERO, FMT_INT, PCT_MAX, true);
+        value(detail.sideSlopePct()),
+        band(ZERO, FMT_INT, PCT_MAX), true);
 
     MaterialComposition material = detail.materialComposition();
     requireRange(issues, "solidRockPct", prefix + " Solid (Hard) Rock (%)",
-        value(material == null ? null : material.solidRockPct()), ZERO, FMT_INT, PCT_MAX, false);
+        value(material == null ? null : material.solidRockPct()),
+        band(ZERO, FMT_INT, PCT_MAX), false);
     requireRange(issues, "rippableRockPct", prefix + " Ripple Rock (%)",
-        value(material == null ? null : material.rippableRockPct()), ZERO, FMT_INT, PCT_MAX, false);
+        value(material == null ? null : material.rippableRockPct()),
+        band(ZERO, FMT_INT, PCT_MAX), false);
     requireRange(issues, "coarsePct", prefix + " Coarse (%)",
-        value(material == null ? null : material.coarsePct()), ZERO, FMT_INT, PCT_MAX, false);
+        value(material == null ? null : material.coarsePct()),
+        band(ZERO, FMT_INT, PCT_MAX), false);
     requireRange(issues, "finePct", prefix + " Fine (%)",
-        value(material == null ? null : material.finePct()), ZERO, FMT_INT, PCT_MAX, false);
+        value(material == null ? null : material.finePct()),
+        band(ZERO, FMT_INT, PCT_MAX), false);
     requireRange(issues, "organicPct", prefix + " Organic (%)",
-        value(material == null ? null : material.organicPct()), ZERO, FMT_INT, PCT_MAX, false);
+        value(material == null ? null : material.organicPct()),
+        band(ZERO, FMT_INT, PCT_MAX), false);
     // Both bounds are 100, which selects the must-equal message. The legacy total coerces nulls to
     // zero and is never absent, so an untouched material breakdown reports 0 against 100.
     requireRange(issues, "materialTypeTotal", prefix + " Material Type Total (%)",
-        value(material == null ? null : material.totalPct()), PCT_MAX, FMT_INT, PCT_MAX, false);
+        value(material == null ? null : material.totalPct()),
+        band(PCT_MAX, FMT_INT, PCT_MAX), false);
 
     SubGrade subGrade = detail.subGrade();
     requireRange(issues, "subGradeLength", prefix + " Sub-Grade: Length (km)",
-        field(subGrade, SubGrade::length), ZERO, FMT_3DP, PCT_MAX, false);
+        field(subGrade, SubGrade::length),
+        band(ZERO, FMT_3DP, PCT_MAX), false);
     requireRange(issues, "subGradeSurfaceWidth", prefix + " Sub-Grade: Surface Width (m)",
-        field(subGrade, SubGrade::surfaceWidth), ZERO, FMT_1DP, WIDTH_MAX, false);
+        field(subGrade, SubGrade::surfaceWidth),
+        band(ZERO, FMT_1DP, WIDTH_MAX), false);
     requireRange(issues, "subGradeActualCost", prefix + " Sub-Grade: Actual Cost ($)",
-        field(subGrade, SubGrade::actualCost), ZERO, FMT_MONEY, SEVEN_DIGITS, false);
+        field(subGrade, SubGrade::actualCost),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "subGradeTtTransfer", prefix + " Sub-Grade: TtT Transfer ($)",
-        field(subGrade, SubGrade::ttTransfer), SEVEN_DIGITS.negate(), FMT_MONEY, SEVEN_DIGITS,
-        false);
+        field(subGrade, SubGrade::ttTransfer),
+        band(SEVEN_DIGITS.negate(), FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "subGradeOtherTransfer", prefix + " Sub-Grade: Other Transfer ($)",
-        field(subGrade, SubGrade::otherTransfer), SEVEN_DIGITS.negate(), FMT_MONEY, SEVEN_DIGITS,
-        false);
+        field(subGrade, SubGrade::otherTransfer),
+        band(SEVEN_DIGITS.negate(), FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "subGradeTotalCosts", prefix + " Sub-Grade: Total Costs ($)",
-        field(subGrade, SubGrade::totalCosts), EIGHT_DIGITS.negate(), FMT_MONEY, EIGHT_DIGITS,
-        false);
+        field(subGrade, SubGrade::totalCosts),
+        band(EIGHT_DIGITS.negate(), FMT_MONEY, EIGHT_DIGITS), false);
     requireRange(issues, "lessBridges", prefix + " Sub-Grade: Less Bridges ($)",
-        field(subGrade, SubGrade::lessBridges), ZERO, FMT_MONEY, SEVEN_DIGITS, false);
+        field(subGrade, SubGrade::lessBridges),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "lessCulverts", prefix + " Sub-Grade: Less Culverts ($)",
-        field(subGrade, SubGrade::lessCulverts), ZERO, FMT_MONEY, SEVEN_DIGITS, false);
+        field(subGrade, SubGrade::lessCulverts),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "lessLandings", prefix + " Sub-Grade: Less Landing ($)",
-        field(subGrade, SubGrade::lessLandings), ZERO, FMT_MONEY, SEVEN_DIGITS, false);
+        field(subGrade, SubGrade::lessLandings),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "lessEndHaul", prefix + " Sub-Grade: Less End Haul ($)",
-        field(subGrade, SubGrade::lessEndHaul), ZERO, FMT_MONEY, SEVEN_DIGITS, false);
+        field(subGrade, SubGrade::lessEndHaul),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "lessOverland", prefix + " Sub-Grade: Less Overland ($)",
-        field(subGrade, SubGrade::lessOverland), ZERO, FMT_MONEY, SEVEN_DIGITS, false);
+        field(subGrade, SubGrade::lessOverland),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "lessOtherEng", prefix + " Sub-Grade: Less Other Eng ($)",
-        field(subGrade, SubGrade::lessOtherEng), ZERO, FMT_MONEY, SEVEN_DIGITS, false);
+        field(subGrade, SubGrade::lessOtherEng),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), false);
     requireRange(issues, "subGradeTotal", prefix + " Sub-Grade: Total ($)",
-        field(subGrade, SubGrade::total), EIGHT_DIGITS.negate(), FMT_MONEY_2DP, EIGHT_DIGITS,
-        false);
+        field(subGrade, SubGrade::total),
+        band(EIGHT_DIGITS.negate(), FMT_MONEY_2DP, EIGHT_DIGITS), false);
     requireRange(issues, "subGradeCostPerLength", prefix + " Sub-Grade: $/km",
-        field(subGrade, SubGrade::costPerLength), EIGHT_DIGITS.negate(), FMT_MONEY_2DP,
-        EIGHT_DIGITS, false);
+        field(subGrade, SubGrade::costPerLength),
+        band(EIGHT_DIGITS.negate(), FMT_MONEY_2DP, EIGHT_DIGITS), false);
 
     Stabilizing stabilizing = detail.stabilizing();
     boolean crushed =
         stabilizing != null && BALLAST_CRUSHED.equals(stabilizing.ballastMethodCode());
 
     requireRange(issues, "stabilizingLength", prefix + " Additional Stabilizing: Length (km)",
-        field(stabilizing, Stabilizing::length), ZERO, FMT_3DP, new BigDecimal("999.999"), crushed);
+        field(stabilizing, Stabilizing::length),
+        band(ZERO, FMT_3DP, new BigDecimal("999.999")), crushed);
     requireRange(issues, "stabilizingSurfaceWidth",
         prefix + " Additional Stabilizing: Surface Width (m)",
-        field(stabilizing, Stabilizing::surfaceWidth), ZERO, FMT_1DP, WIDTH_MAX,
-        crushed);
+        field(stabilizing, Stabilizing::surfaceWidth),
+        band(ZERO, FMT_1DP, WIDTH_MAX), crushed);
     requireRange(issues, "stabilizingDepth", prefix + " Additional Stabilizing: Depth (m)",
-        field(stabilizing, Stabilizing::depth), ZERO, FMT_2DP_SMALL, new BigDecimal("99.9"),
-        crushed);
+        field(stabilizing, Stabilizing::depth),
+        band(ZERO, FMT_2DP_SMALL, new BigDecimal("99.9")), crushed);
     requireRange(issues, "stabilizingDistanceToSource",
         prefix + " Additional Stabilizing: Distance to Source (km)",
-        field(stabilizing, Stabilizing::distanceToSource), ZERO, FMT_1DP, WIDTH_MAX,
-        crushed);
+        field(stabilizing, Stabilizing::distanceToSource),
+        band(ZERO, FMT_1DP, WIDTH_MAX), crushed);
 
     if (!crushed) {
       return new DetailOutcome(
@@ -276,19 +293,24 @@ static DetailOutcome evaluateRoadDetail(
         stabilizing.ballastMaterialCode());
     requireRange(issues, "stabilizingActualCost",
         prefix + " Additional Stabilizing: Actual Cost ($)",
-        stabilizing.actualCost(), ZERO, FMT_MONEY, SEVEN_DIGITS, true);
+        stabilizing.actualCost(),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), true);
     // Floor of ZERO, while the entry form accepts down to -9,999,999 for both transfers. A value
     // the form allowed is therefore reported here. Legacy carries the same disagreement.
     requireRange(issues, "stabilizingTtTransfer",
         prefix + " Additional Stabilizing: TtT Transfer ($)",
-        stabilizing.ttTransfer(), ZERO, FMT_MONEY, SEVEN_DIGITS, true);
+        stabilizing.ttTransfer(),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), true);
     requireRange(issues, "stabilizingOtherTransfer",
         prefix + " Additional Stabilizing: Other Transfer ($)",
-        stabilizing.otherTransfer(), ZERO, FMT_MONEY, SEVEN_DIGITS, true);
+        stabilizing.otherTransfer(),
+        band(ZERO, FMT_MONEY, SEVEN_DIGITS), true);
     requireRange(issues, "stabilizingTotal", prefix + " Additional Stabilizing: total ($)",
-        stabilizing.total(), new BigDecimal("-999999"), FMT_MONEY_NARROW, SEVEN_DIGITS, false);
+        stabilizing.total(),
+        band(new BigDecimal("-999999"), FMT_MONEY_NARROW, SEVEN_DIGITS), false);
     requireRange(issues, "stabilizingCostPerLength", prefix + " Additional Stabilizing: $/km",
-        stabilizing.costPerLength(), ZERO, FMT_MONEY_WIDE, EIGHT_DIGITS, false);
+        stabilizing.costPerLength(),
+        band(ZERO, FMT_MONEY_WIDE, EIGHT_DIGITS), false);
 
     return new DetailOutcome(
         detail.roadDetailId(), detail.rowNumber(), detail.roadDetailLabel(), issues);
@@ -301,6 +323,26 @@ private static void requirePresent(
     }
   }
 
+  /**
+   * One rule's inclusive bounds and the pattern both are rendered with.
+   *
+   * <p>Bundled into a record so {@link #requireRange} takes six parameters rather than eight (Sonar
+   * brain-overload, 2026-08-18). The three genuinely travel together: legacy formats BOTH bounds
+   * with the LOWER bound's pattern, which is why one format field serves both and why they cannot
+   * sensibly be separated.
+   *
+   * @param lower the inclusive lower bound
+   * @param upper the inclusive upper bound; equal to {@code lower} selects the must-equal message
+   * @param format the legacy number pattern both bounds are rendered with
+   */
+  private record Band(BigDecimal lower, BigDecimal upper, String format) {
+  }
+
+  /** Reads as a bound pair at the call site, in the legacy lower/format/upper order. */
+  private static Band band(BigDecimal lower, String format, BigDecimal upper) {
+    return new Band(lower, upper, format);
+  }
+
   /**
    * The legacy numeric rule: an absent optional value passes, an absent required value is reported
    * as missing, and otherwise the value must sit inside the inclusive range.
@@ -311,8 +353,11 @@ private static void requirePresent(
    * instead, which agrees for every rule in this schedule and does not depend on that accident.
    */
   private static void requireRange(
-      List<Issue> issues, String field, String label, BigDecimal value,
-      BigDecimal lower, String lowerFormat, BigDecimal upper, boolean required) {
+      List<Issue> issues, String field, String label, BigDecimal value, Band band,
+      boolean required) {
+    BigDecimal lower = band.lower();
+    BigDecimal upper = band.upper();
+    String lowerFormat = band.format();
     if (value == null) {
       if (required) {
         issues.add(new Issue(field, label, MSG_REQUIRED, List.of()));