SONARJAVA-6825: Implement rule S9360 - Constant expressions and comparisons should be simplified

its/ruling/src/test/resources/commons-beanutils/java-S9360.json

@@ -0,0 +1,8 @@
+{
+"commons-beanutils:commons-beanutils:src/main/java/org/apache/commons/beanutils2/ConstructorUtils.java": [
+106,
+154,
+218,
+267
+]
+}

its/ruling/src/test/resources/eclipse-jetty-similar-to-main/java-S9360.json

@@ -0,0 +1,59 @@
+{
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/HttpStatus.java": [
+343,
+358,
+373,
+388,
+403
+],
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/HttpURI.java": [
+1028
+],
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/MimeTypes.java": [
+431,
+436,
+445,
+453,
+455,
+459,
+465,
+471,
+477,
+483,
+489,
+495,
+497,
+501,
+503,
+514,
+514,
+515,
+575,
+615,
+617,
+622,
+624,
+628,
+634,
+640,
+646,
+652,
+658,
+664,
+666,
+670,
+677,
+684
+],
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/pathmap/ServletPathSpec.java": [
+93,
+414
+],
+"org.eclipse.jetty:jetty-project:jetty-io/src/test/java/org/eclipse/jetty/io/ArrayByteBufferPoolTest.java": [
+94
+],
+"org.eclipse.jetty:jetty-project:jetty-server/src/test/java/org/eclipse/jetty/server/HttpServerTestBase.java": [
+744,
+835
+]
+}

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

@@ -0,0 +1,75 @@
+{
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/HttpStatus.java": [
+343,
+358,
+373,
+388,
+403
+],
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/HttpURI.java": [
+1028
+],
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/MimeTypes.java": [
+431,
+436,
+445,
+453,
+455,
+459,
+465,
+471,
+477,
+483,
+489,
+495,
+497,
+501,
+503,
+514,
+514,
+515,
+575,
+615,
+617,
+622,
+624,
+628,
+634,
+640,
+646,
+652,
+658,
+664,
+666,
+670,
+677,
+684
+],
+"org.eclipse.jetty:jetty-project:jetty-http/src/main/java/org/eclipse/jetty/http/pathmap/ServletPathSpec.java": [
+93,
+414
+],
+"org.eclipse.jetty:jetty-project:jetty-io/src/test/java/org/eclipse/jetty/io/ArrayByteBufferPoolTest.java": [
+94
+],
+"org.eclipse.jetty:jetty-project:jetty-server/src/test/java/org/eclipse/jetty/server/HttpServerTestBase.java": [
+744,
+835
+],
+"org.eclipse.jetty:jetty-project:jetty-util-ajax/src/main/java/org/eclipse/jetty/util/ajax/AsyncJSON.java": [
+1275
+],
+"org.eclipse.jetty:jetty-project:jetty-util/src/main/java/org/eclipse/jetty/util/StringUtil.java": [
+901,
+907,
+925,
+942,
+957,
+962,
+978
+],
+"org.eclipse.jetty:jetty-project:jetty-util/src/main/java/org/eclipse/jetty/util/security/Password.java": [
+117,
+132
+]
+}

its/ruling/src/test/resources/guava/java-S9360.json

@@ -0,0 +1,17 @@
+{
+"com.google.guava:guava:src/com/google/common/base/SmallCharMatcher.java": [
+61
+],
+"com.google.guava:guava:src/com/google/common/io/LittleEndianDataInputStream.java": [
+82,
+225
+],
+"com.google.guava:guava:src/com/google/common/math/LongMath.java": [
+234
+],
+"com.google.guava:guava:src/com/google/common/net/MediaType.java": [
+628,
+631,
+632
+]
+}

java-checks-test-sources/default/src/main/files/non-compiling/checks/YodaConditionCheckSample.java

@@ -0,0 +1,10 @@
+package checks;
+
+class YodaConditionCheckSample {
+
+  void unknownLiteralType() {
+    Object x = new Object();
+    if (UNKNOWN_LITERAL == x) { } // Compliant - UNKNOWN_LITERAL is not a valid literal
+  }
+
+}

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

@@ -0,0 +1,193 @@
+package checks;
+
+class YodaConditionCheckSample {
+
+  void testIntLiteral() {
+    int count = 0;
+    int x = 5;
+    if (0 == count) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^
+    if (5 != x) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^
+    if (count == 0) { } // Compliant
+    if (x != 5) { } // Compliant
+  }
+
+  void testNullLiteral() {
+    Object obj = null;
+    Object myObject = null;
+    if (null == obj) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^^^^
+    if (null != myObject) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^^^^
+    if (obj == null) { } // Compliant
+    if (myObject != null) { } // Compliant
+    if (null == null) { } // Compliant
+  }
+
+  void testBooleanLiteral() {
+    boolean flag = true;
+    boolean result = false;
+    if (true == flag) { } // Compliant - boolean literal comparisons handled by S1125
+    if (false != result) { } // Compliant - boolean literal comparisons handled by S1125
+    if (flag == true) { } // Compliant
+    if (result != false) { } // Compliant
+  }
+
+  void testStringLiteral() {
+    String str = "hello";
+    String value = "";
+    if ("hello" == str) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^^^^^^^
+    if ("" != value) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^^
+    if (str == "hello") { } // Compliant
+    if (value != "") { } // Compliant
+  }
+
+  void testCharLiteral() {
+    char ch = 'a';
+    if ('a' == ch) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^^^
+    if (ch == 'a') { } // Compliant
+  }
+
+  void testFloatingPointLiteral() {
+    double doubleValue = 0.0;
+    if (0.0 == doubleValue) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^^^
+    if (doubleValue == 0.0) { } // Compliant
+  }
+
+  void testNestedParentheses() {
+    int count = 0;
+    Object obj = new Object();
+    if ((0) == count) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+    if (((null)) == obj) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//        ^^^^
+  }
+
+  void testLessThanGreaterThan() {
+    int count = 0;
+    int x = 5;
+    if (0 < count) { } // Noncompliant {{Put the variable on the left side of this comparison and invert the operator.}}
+//      ^
+    if (5 > x) { } // Noncompliant {{Put the variable on the left side of this comparison and invert the operator.}}
+//      ^
+    if (count > 0) { } // Compliant
+    if (x < 5) { } // Compliant
+  }
+
+  void testLessThanOrEqualGreaterThanOrEqual() {
+    int count = 0;
+    int x = 5;
+    if (0 <= count) { } // Noncompliant {{Put the variable on the left side of this comparison and invert the operator.}}
+//      ^
+    if (5 >= x) { } // Noncompliant {{Put the variable on the left side of this comparison and invert the operator.}}
+//      ^
+    if (count >= 0) { } // Compliant
+    if (x <= 5) { } // Compliant
+  }
+
+  void testNonComparisonContexts() {
+    int count = 0;
+    int a = 1;
+    int b = 2;
+    count = 0; // Compliant - assignment
+    int sum = a + 5; // Compliant - arithmetic
+    int product = 5 * b; // Compliant - arithmetic
+  }
+
+  void testTernaryOperator() {
+    boolean condition = true;
+    int result = condition ? 5 : 10; // Compliant
+    if (condition) { } // Compliant
+  }
+
+  void testArrayAccess() {
+    int[] array = {1, 2, 3};
+    if (0 == array[0]) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^
+    if (array[0] == 0) { } // Compliant
+  }
+
+  void testUnaryMinusPlusYoda() {
+    int index = 0;
+    if (-1 == index) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^^
+    if (+1 == index) { } // Noncompliant {{Put the variable on the left side of this comparison.}}
+//      ^^
+    if (index == -1) { } // Compliant
+    if (index == +1) { } // Compliant
+  }
+
+  void testBothLiterals() {
+    if (0 == 0) { } // Compliant - both sides are literals
+    if (5 != 10) { } // Compliant - both sides are literals
+    if (true == false) { } // Compliant - both sides are literals
+    if (0 == -1) { } // Compliant - both sides are literals
+    if (-1 == 0) { } // Compliant - both sides are literals
+    if (-1 == -2) { } // Compliant - both sides are literals
+  }
+
+  void testBothVariables() {
+    int count = 0;
+    int otherCount = 0;
+    Object obj1 = null;
+    Object obj2 = null;
+    if (count == otherCount) { } // Compliant - both are variables
+    if (obj1 == obj2) { } // Compliant - both are variables
+  }
+
+  void testConstantMathCalls() {
+    int max = Math.max(5, 10); // Noncompliant {{Replace this call to "max" with the precomputed constant value.}}
+//            ^^^^^^^^
+    int min = Math.min(3, 7); // Noncompliant {{Replace this call to "min" with the precomputed constant value.}}
+//            ^^^^^^^^
+    double sqrt = Math.sqrt(16.0); // Noncompliant {{Replace this call to "sqrt" with the precomputed constant value.}}
+//                ^^^^^^^^^
+    int abs = Math.abs(-5); // Noncompliant {{Replace this call to "abs" with the precomputed constant value.}}
+//            ^^^^^^^^
+    long rounded = Math.round(3.14); // Noncompliant {{Replace this call to "round" with the precomputed constant value.}}
+//                 ^^^^^^^^^^
+    double floor = Math.floor(3.7); // Noncompliant {{Replace this call to "floor" with the precomputed constant value.}}
+//                 ^^^^^^^^^^
+    double ceil = Math.ceil(3.2); // Noncompliant {{Replace this call to "ceil" with the precomputed constant value.}}
+//                ^^^^^^^^^
+  }
+
+  void testConstantMathCallsCompliant() {
+    int x = 5;
+    int y = 10;
+    int max = Math.max(x, 10); // Compliant - x is not a literal
+    int min = Math.min(3, y); // Compliant - y is not a literal
+    double sqrt = Math.sqrt(x); // Compliant - x is not a literal
+    int abs = Math.abs(x); // Compliant - x is not a literal
+    int maxVar = Math.max(x, y); // Compliant - neither is a literal
+  }
+
+  void testConstantMathCallsWithUnaryMinus() {
+    int abs = Math.abs(-10); // Noncompliant {{Replace this call to "abs" with the precomputed constant value.}}
+//            ^^^^^^^^
+    int max = Math.max(-5, -3); // Noncompliant {{Replace this call to "max" with the precomputed constant value.}}
+//            ^^^^^^^^
+    double sqrt = Math.sqrt(+4.0); // Noncompliant {{Replace this call to "sqrt" with the precomputed constant value.}}
+//                ^^^^^^^^^
+  }
+
+  void testTranscendentalMathCallsCompliant() {
+    double pow = Math.pow(2.0, 3.0); // Compliant - transcendental functions excluded (result may vary across JVMs)
+    double sin = Math.sin(0.5); // Compliant
+    double cos = Math.cos(0.5); // Compliant
+    double log = Math.log(2.0); // Compliant
+    double exp = Math.exp(1.0); // Compliant
+    double cbrt = Math.cbrt(8.0); // Compliant - not exactly specified
+    double deg = Math.toDegrees(1.0); // Compliant - not exactly specified
+    double rad = Math.toRadians(90.0); // Compliant - not exactly specified
+  }
+
+  void testNonMathMethodCalls() {
+    String result = String.valueOf(5); // Compliant - not a Math method
+    int hash = Integer.hashCode(42); // Compliant - not a Math method
+  }
+}