report what a rule cannot verify instead of passing

Removes the remaining ways a rule stayed quiet.

allowEmptyShould(true) is gone everywhere. A rule that selects nothing reported
success, indistinguishable from a rule that is satisfied, which is what let a
dead rule survive. EmptySelectionTest pins this for all eight rules that narrow
their input. Consequence to be aware of: CommonArchRuleCollection now fails in a
project with no controllers or no @Store classes, so implement it only where
those exist.

The @nested name rule skipped a nested class silently whenever the production
class was missing and the nested class was not inside a group - so the case with
nothing to compare against was the one case never reported. It now reports, and
in exchange honours @ArchIgnoreNoProductionCounterpart: a test class that
declares it has no production counterpart has no production methods either.

The security-test rule accepted any @nested class *starting with* the method
name, so getAll() counted as covered by GetAllArchived. It now requires the name
to match exactly or to continue with "$", which keeps grouped @nested classes
working.

The SortMappings rule swallowed every failure to read a field into a log.warn -
and the build has no SLF4J provider, so the warning was discarded outright. A
non-static field, an unreadable field, an unresolvable enum type and a value
that is not a Map are all violations now. Non-static in particular is reported
as such, since it can never be validated.

Finally, @ArchIgnoreNoProductionCounterpart and @ArchIgnoreGroupName no longer
meta-annotate ArchUnit's @ArchIgnore. The ArchUnit JUnit engine resolves
meta-annotations, so annotating a test class skipped *every* @archtest on it and
still reported BUILD SUCCESS - verified: putting it on this project's own
ArchitectureTest turned 11 rules into 11 skips. Both annotations are read by
their own type, so the meta-annotation bought nothing. ArchitectureTest now
carries it in place of the name that was hardcoded into the counterpart rule,
which also keeps the annotation exercised.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: SirCotare

src/main/java/it/aboutbits/archunit/toolbox/rule/base/TestMethodVisibilityArchRule.java

@@ -32,7 +32,6 @@ public boolean test(JavaClass javaClass) {
                 })
                 .should()
                 .bePackagePrivate()
-                .allowEmptyShould(true)
                 .check(classes);
     }
 }

src/main/java/it/aboutbits/archunit/toolbox/rule/base/TestNestedClassMatchNameArchRule.java

@@ -7,12 +7,12 @@
 import com.tngtech.archunit.lang.ArchCondition;
 import com.tngtech.archunit.lang.ConditionEvents;
 import com.tngtech.archunit.lang.SimpleConditionEvent;
+import it.aboutbits.archunit.toolbox.util.TestClassNames;
 import org.jspecify.annotations.NullMarked;
 
 import java.util.stream.Collectors;
 
 import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.classes;
-import static it.aboutbits.archunit.toolbox.config.ArchRuleConfig.TEST_CLASS_SUFFIXES;
 import static it.aboutbits.archunit.toolbox.util.LineNumberUtil.getLineNumber;
 
 @SuppressWarnings({"checkstyle:InterfaceIsType", "java:S1214"})
@@ -21,14 +21,18 @@ public interface TestNestedClassMatchNameArchRule {
     @SuppressWarnings({"unused", "checkstyle:MethodName", "java:S100"})
     @ArchTest
     default void nested_test_classes_have_matching_production_method_name(JavaClasses classes) {
-        classes().that()
-                .haveNameMatching(".+(" + String.join("|", TEST_CLASS_SUFFIXES) + ")$")
+        classes().that(TestClassNames.testClasses())
                 .and()
                 .areNotAnnotatedWith(org.junit.jupiter.api.Disabled.class)
                 .and()
                 .areNotAnnotatedWith(com.tngtech.archunit.junit.ArchIgnore.class)
+                .and()
+                /*
+                 * A test class that declares it has no production counterpart has no production
+                 * methods to match its @Nested classes against either.
+                 */
+                .areNotAnnotatedWith(it.aboutbits.archunit.toolbox.support.ArchIgnoreNoProductionCounterpart.class)
                 .should(new HaveNestedClassesThatHaveAMatchingProductionMethodName(classes))
-                .allowEmptyShould(true)
                 .check(classes);
     }
 
@@ -113,26 +117,28 @@ public void check(JavaClass testClass, ConditionEvents events) {
 
                 var productionClassName = "%s.%s%s".formatted(
                         testClass.getPackageName(),
-                        testClass.getSimpleName()
-                                .replaceAll("(" + String.join("|", TEST_CLASS_SUFFIXES) + ")$", ""),
+                        TestClassNames.productionClassSimpleName(testClass.getSimpleName()),
                         enclosingClassSuffix.orElse("")
                 );
 
                 var productionClassOptional = allClasses.stream()
                         .filter(clazz -> clazz.getFullName().equals(productionClassName))
                         .findFirst();
 
-                if (productionClassOptional.isEmpty() && enclosingClassSuffix.isPresent()) {
+                /*
+                 * Reported whether or not the @Nested class is inside a @Nested group. Without a
+                 * production class there is nothing to match the name against, so staying silent
+                 * here means the @Nested class is never checked at all.
+                 */
+                if (productionClassOptional.isEmpty()) {
                     var message = "The @Nested test class <%s> (%s.java:%s)%ndoes not have a matching production class <%s>".formatted(
                             nestedClass.getName(),
                             nestedClassBaseClassSimpleName,
                             nestedClassLineNumber,
                             productionClassName
                     );
                     events.add(SimpleConditionEvent.violated(nestedClass, message));
-                }
-
-                if (productionClassOptional.isPresent()) {
+                } else {
                     var productionClass = productionClassOptional.get();
 
                     var methodExists = productionClass.getMethods()

src/main/java/it/aboutbits/archunit/toolbox/rule/base/TestNestedClassVisibilityArchRule.java

@@ -17,7 +17,6 @@ default void nested_test_classes_must_be_package_private(JavaClasses classes) {
                 .areAnnotatedWith(org.junit.jupiter.api.Nested.class)
                 .should()
                 .bePackagePrivate()
-                .allowEmptyShould(true)
                 .check(classes);
     }
 }

src/main/java/it/aboutbits/archunit/toolbox/rule/common/ControllerRequestMappingsMustBeSecurityTested.java

@@ -80,14 +80,15 @@ public void check(JavaMethod method, ConditionEvents events) {
                 return;
             }
 
+            var expectedNestedClassName = "%s$%s".formatted(
+                    securityTestClass.getName(),
+                    expectedNestedMethodClassName
+            );
+
             var nestedMethodTestClassFound = securityTestClass.getPackage()
                     .getClasses()
                     .stream()
-                    .anyMatch(clazz -> clazz.getName()
-                            .startsWith("%s$%s".formatted(
-                                    securityTestClass.getName(),
-                                    expectedNestedMethodClassName
-                            ))
+                    .anyMatch(clazz -> isExpectedNestedClass(clazz.getName(), expectedNestedClassName)
                             && clazz.isAnnotatedWith(org.junit.jupiter.api.Nested.class)
                             && !clazz.isAnnotatedWith(com.tngtech.archunit.junit.ArchIgnore.class)
                             && !clazz.isAnnotatedWith(it.aboutbits.archunit.toolbox.support.ArchIgnoreGroupName.class)
@@ -106,5 +107,15 @@ public void check(JavaMethod method, ConditionEvents events) {
                 ));
             }
         }
+
+        /*
+         * The @Nested class named after the controller method, or a @Nested class grouped inside it
+         * (GetAll$WhenAdmin). Matching on a bare prefix would also accept an unrelated longer
+         * sibling, so getAll() would count as covered by a @Nested class named GetAllArchived.
+         */
+        private static boolean isExpectedNestedClass(String candidateName, String expectedName) {
+            return candidateName.equals(expectedName)
+                    || candidateName.startsWith(expectedName + "$");
+        }
     }
 }