Java Code One Task

mandatory-rules.md

Always

The non-negotiable rules. Tests: JUnit assertions, never AssertJ; Mockito mocks or spies, never hand-written fake implementations (an abstract class is tested through a CALLS_REAL_METHODS mock); test methods named methodBeingTested_whenCondition_expectedResult; one test class per public class, never one shared across several implementations; *Test for unit tests and *IT for integration tests; standard member ordering and full Javadoc in test classes too. Style: var wherever possible, including an explicit type witness for generic static factories (List.<String>of()); records validated in the compact constructor, with collections defensively copied (or SpotBugs EI_EXPOSE_REP fails the build); final on every parameter (Checkstyle FinalParameters); Javadoc on every type, method, constructor, and field; named constants instead of magic numbers; stream predicates over manual loops for simple scans; getFirst()/getLast(); method references over forwarding lambdas; switch expressions over if/else if chains; no redundant this; null-safe utility predicates from a library already on the classpath; LF line endings, never System.lineSeparator() or %n.

code-style.md

Always

Type inference — var for locals wherever the type is inferable, and the specific cases where an explicit type earns its keep (a right-hand side that doesn’t name the type, numeric width, needing the interface rather than the implementation, an un-writable inferred type, a bare diamond). final wherever possible: fields, locals, parameters, plus classes and methods that aren’t designed to be extended — with the caveats that matter, since a proxying framework cannot subclass a final class and Mockito 4 and earlier cannot mock one. Then immutability and records (including shallow-immutability defensive copying), narrowest-possible visibility, naming, exception and null conventions (IllegalArgumentException naming the offending parameter, fail fast, never swallow, no System.out), and collections/Optional rules.

class-member-ordering.md

The task adds a new type, or adds/moves a member in an existing one

The public-to-private declaration order every type follows — static constants, static fields, instance fields, static initialisers, constructors, methods, then nested types, each band ordered public → protected → package-private → private. Plus the two cross-cutting rules: overloads stay contiguous and sit where their most visible member would, and a private helper lives in the private band rather than next to its caller. Includes an annotated skeleton class, the variations for interfaces/enums/records, and the rules for applying the order to an existing file without producing an unreviewable diff.

javadoc.md

The task adds or changes a type or a public/protected member

Full Javadoc as a hard requirement — on every type, method, constructor, and field, private ones and test sources included: a standalone summary sentence, the caller’s contract, @param for every parameter, type parameter, and record component, @return, and @throws for every handleable exception — the @throws list being what the tests are written against. Plus interface Javadoc as the implementation contract, what an overridable method must document for its subclasses, {@inheritDoc}, when a private member deserves a Javadoc says for private members and in test sources, and the mechanics that otherwise fail a doclint build.

testing.md

The task writes or updates tests — nearly every task

The fixed rules from mandatory-rules.md first (JUnit not AssertJ, Mockito not fakes, naming, one test class per public class), then the package’s existing conventions for everything those leave open; what to cover (the changed behaviour through the public API, one test per documented @throws, boundaries) and what not to; JUnit 5 mechanics (assertThrows, @ParameterizedTest, @Nested, no shared mutable state, no Thread.sleep); why private methods are tested through public behaviour rather than by widening visibility; and disciplined mocking — mock what you don’t own, never a hand-written fake, never the type under test, verify only when the interaction is the behaviour.