SONARJAVA-6824: Fix hasExactlyOneArgumentDifference to count differences and add ruling expectations

The method was using a boolean flag that returned true when any arguments
differed, causing false positives for cases with multiple differing arguments.
Now uses an integer counter to ensure exactly one argument differs.
Also adds eclipse-jetty ruling expectations and test cases for multiple
argument differences.

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

Author: romainbrenguier

its/ruling/src/test/resources/eclipse-jetty/java-S9358.json

@@ -0,0 +1,19 @@
+{
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/QuotedQualityCSV.java": [
+129
+],
+"org.eclipse.jetty:jetty-project:jetty-jmx/src/main/java/org/eclipse/jetty/jmx/MBeanContainer.java": [
+362,
+373
+],
+"org.eclipse.jetty:jetty-project:jetty-util/src/main/java/org/eclipse/jetty/util/JavaVersion.java": [
+58
+],
+"org.eclipse.jetty:jetty-project:jetty-util/src/main/java/org/eclipse/jetty/util/ssl/SniX509ExtendedKeyManager.java": [
+178,
+192
+],
+"org.eclipse.jetty:jetty-project:jetty-util/src/test/java/org/eclipse/jetty/util/statistic/CounterStatisticTest.java": [
+91
+]
+}

java-checks-test-sources/default/src/main/java/checks/TernaryOperatorSameOperationCheckSample.java

@@ -26,6 +26,9 @@ void testMethodInvocations() {
     // Method invocations with multiple args where some differ - Noncompliant
     String m5 = condition ? foo(a, x) : foo(b, x); // Noncompliant
 
+    // Method invocations with multiple args where all differ - Compliant
+    String m6 = condition ? foo(a, x) : foo(b, y); // Compliant - more than one argument differs
+
     // Method invocations - Compliant (different operations or same arguments)
     String c1 = condition ? foo(a) : bar(b); // Compliant - different methods
     String c2 = condition ? foo(a) : foo(a); // Compliant - same arguments
@@ -63,6 +66,9 @@ void testNewClass() {
     // New class with multiple args where some differ - Noncompliant
     Object n2 = condition ? new Foo(a, b) : new Foo(b, b); // Noncompliant
 
+    // New class with multiple args where all differ - Compliant
+    Object n3 = condition ? new Foo(a, a) : new Foo(b, b); // Compliant - more than one argument differs
+
     // New class - Compliant
     Object c4 = condition ? new Foo(a) : new Bar(b); // Compliant - different classes
     Object c5 = condition ? new Foo(a) : new Foo(a); // Compliant - same arguments

java-checks/src/main/java/org/sonar/java/checks/TernaryOperatorSameOperationCheck.java

@@ -97,13 +97,13 @@ private static boolean hasExactlyOneArgumentDifference(List<? extends Expression
     if (leftArgs.size() != rightArgs.size()) {
       return false;
     }
-    boolean anyDifferent = false;
+    int differences = 0;
     for (int i = 0; i < leftArgs.size(); i++) {
       if (!sameTree(leftArgs.get(i), rightArgs.get(i))) {
-        anyDifferent = true;
+        differences++;
       }
     }
-    return anyDifferent;
+    return differences == 1;
   }
 
   private static boolean sameArrayAccess(ArrayAccessExpressionTree left, ArrayAccessExpressionTree right) {