Bump org.jvnet.hudson.plugins:analysis-pom from 11.2934.va_a_d795c46a_7b_ to 11.2958.v63511c4c1160 #580
+1
−1
ci.jenkins.io / PMD
failed
Dec 15, 2025
8 new issues
| Total | New | Outstanding | Fixed | Trend |
|---|---|---|---|---|
| 8 | 8 | 0 | 0 | 👎 |
Reference build: Plugins » coverage-plugin » main #475
Details
Severity distribution of new issues
| Error | Warning High | Warning Normal | Warning Low |
|---|---|---|---|
| 0 | 0 | 8 | 0 |
Annotations
ci-jenkins-io / PMD
EnumComparison
NORMAL:
Enums should be compared using ==.
Raw output
When comparing enums, `equals()` should be avoided and `==` should be preferred. Using `==` has some advantages: * same semantic as `equals()` * less problematic with possible null pointer exceptions * supports static type check: If you compare two incompatible enum types, the compiler will tell you. When using equals, you'll only get noticed at runtime or not at all. This rule implements SonarSource rule [S4551](https://sonarsource.github.io/rspec/#/rspec/S4551). Note, that only primitive types and enums should be compared using `==`. To compare other objects, `equals()` is the correct way. See {%rule java/errorprone/CompareObjectsWithEquals %} and {%rule java/errorprone/UseEqualsToCompareStrings %}. <pre> <code> enum Color { RED, GREEN, BLUE } class ColorTester { boolean isRed(Color color) { return color.equals(Color.RED); // violation } boolean isGreen(Color color) { return color == Color.GREEN; // preferred } } </code> </pre> <a href="https://docs.pmd-code.org/pmd-doc-7.19.0/pmd_rules_java_bestpractices.html#enumcomparison"> See PMD documentation. </a>
ci-jenkins-io / PMD
EnumComparison
NORMAL:
Enums should be compared using ==.
Raw output
When comparing enums, `equals()` should be avoided and `==` should be preferred. Using `==` has some advantages: * same semantic as `equals()` * less problematic with possible null pointer exceptions * supports static type check: If you compare two incompatible enum types, the compiler will tell you. When using equals, you'll only get noticed at runtime or not at all. This rule implements SonarSource rule [S4551](https://sonarsource.github.io/rspec/#/rspec/S4551). Note, that only primitive types and enums should be compared using `==`. To compare other objects, `equals()` is the correct way. See {%rule java/errorprone/CompareObjectsWithEquals %} and {%rule java/errorprone/UseEqualsToCompareStrings %}. <pre> <code> enum Color { RED, GREEN, BLUE } class ColorTester { boolean isRed(Color color) { return color.equals(Color.RED); // violation } boolean isGreen(Color color) { return color == Color.GREEN; // preferred } } </code> </pre> <a href="https://docs.pmd-code.org/pmd-doc-7.19.0/pmd_rules_java_bestpractices.html#enumcomparison"> See PMD documentation. </a>
ci-jenkins-io / PMD
EnumComparison
NORMAL:
Enums should be compared using ==.
Raw output
When comparing enums, `equals()` should be avoided and `==` should be preferred. Using `==` has some advantages: * same semantic as `equals()` * less problematic with possible null pointer exceptions * supports static type check: If you compare two incompatible enum types, the compiler will tell you. When using equals, you'll only get noticed at runtime or not at all. This rule implements SonarSource rule [S4551](https://sonarsource.github.io/rspec/#/rspec/S4551). Note, that only primitive types and enums should be compared using `==`. To compare other objects, `equals()` is the correct way. See {%rule java/errorprone/CompareObjectsWithEquals %} and {%rule java/errorprone/UseEqualsToCompareStrings %}. <pre> <code> enum Color { RED, GREEN, BLUE } class ColorTester { boolean isRed(Color color) { return color.equals(Color.RED); // violation } boolean isGreen(Color color) { return color == Color.GREEN; // preferred } } </code> </pre> <a href="https://docs.pmd-code.org/pmd-doc-7.19.0/pmd_rules_java_bestpractices.html#enumcomparison"> See PMD documentation. </a>
ci-jenkins-io / PMD
EnumComparison
NORMAL:
Enums should be compared using ==.
Raw output
When comparing enums, `equals()` should be avoided and `==` should be preferred. Using `==` has some advantages: * same semantic as `equals()` * less problematic with possible null pointer exceptions * supports static type check: If you compare two incompatible enum types, the compiler will tell you. When using equals, you'll only get noticed at runtime or not at all. This rule implements SonarSource rule [S4551](https://sonarsource.github.io/rspec/#/rspec/S4551). Note, that only primitive types and enums should be compared using `==`. To compare other objects, `equals()` is the correct way. See {%rule java/errorprone/CompareObjectsWithEquals %} and {%rule java/errorprone/UseEqualsToCompareStrings %}. <pre> <code> enum Color { RED, GREEN, BLUE } class ColorTester { boolean isRed(Color color) { return color.equals(Color.RED); // violation } boolean isGreen(Color color) { return color == Color.GREEN; // preferred } } </code> </pre> <a href="https://docs.pmd-code.org/pmd-doc-7.19.0/pmd_rules_java_bestpractices.html#enumcomparison"> See PMD documentation. </a>
ci-jenkins-io / PMD
EnumComparison
NORMAL:
Enums should be compared using ==.
Raw output
When comparing enums, `equals()` should be avoided and `==` should be preferred. Using `==` has some advantages: * same semantic as `equals()` * less problematic with possible null pointer exceptions * supports static type check: If you compare two incompatible enum types, the compiler will tell you. When using equals, you'll only get noticed at runtime or not at all. This rule implements SonarSource rule [S4551](https://sonarsource.github.io/rspec/#/rspec/S4551). Note, that only primitive types and enums should be compared using `==`. To compare other objects, `equals()` is the correct way. See {%rule java/errorprone/CompareObjectsWithEquals %} and {%rule java/errorprone/UseEqualsToCompareStrings %}. <pre> <code> enum Color { RED, GREEN, BLUE } class ColorTester { boolean isRed(Color color) { return color.equals(Color.RED); // violation } boolean isGreen(Color color) { return color == Color.GREEN; // preferred } } </code> </pre> <a href="https://docs.pmd-code.org/pmd-doc-7.19.0/pmd_rules_java_bestpractices.html#enumcomparison"> See PMD documentation. </a>
ci-jenkins-io / PMD
EnumComparison
NORMAL:
Enums should be compared using ==.
Raw output
When comparing enums, `equals()` should be avoided and `==` should be preferred. Using `==` has some advantages: * same semantic as `equals()` * less problematic with possible null pointer exceptions * supports static type check: If you compare two incompatible enum types, the compiler will tell you. When using equals, you'll only get noticed at runtime or not at all. This rule implements SonarSource rule [S4551](https://sonarsource.github.io/rspec/#/rspec/S4551). Note, that only primitive types and enums should be compared using `==`. To compare other objects, `equals()` is the correct way. See {%rule java/errorprone/CompareObjectsWithEquals %} and {%rule java/errorprone/UseEqualsToCompareStrings %}. <pre> <code> enum Color { RED, GREEN, BLUE } class ColorTester { boolean isRed(Color color) { return color.equals(Color.RED); // violation } boolean isGreen(Color color) { return color == Color.GREEN; // preferred } } </code> </pre> <a href="https://docs.pmd-code.org/pmd-doc-7.19.0/pmd_rules_java_bestpractices.html#enumcomparison"> See PMD documentation. </a>
ci-jenkins-io / PMD
EnumComparison
NORMAL:
Enums should be compared using ==.
Raw output
When comparing enums, `equals()` should be avoided and `==` should be preferred. Using `==` has some advantages: * same semantic as `equals()` * less problematic with possible null pointer exceptions * supports static type check: If you compare two incompatible enum types, the compiler will tell you. When using equals, you'll only get noticed at runtime or not at all. This rule implements SonarSource rule [S4551](https://sonarsource.github.io/rspec/#/rspec/S4551). Note, that only primitive types and enums should be compared using `==`. To compare other objects, `equals()` is the correct way. See {%rule java/errorprone/CompareObjectsWithEquals %} and {%rule java/errorprone/UseEqualsToCompareStrings %}. <pre> <code> enum Color { RED, GREEN, BLUE } class ColorTester { boolean isRed(Color color) { return color.equals(Color.RED); // violation } boolean isGreen(Color color) { return color == Color.GREEN; // preferred } } </code> </pre> <a href="https://docs.pmd-code.org/pmd-doc-7.19.0/pmd_rules_java_bestpractices.html#enumcomparison"> See PMD documentation. </a>
ci-jenkins-io / PMD
EnumComparison
NORMAL:
Enums should be compared using ==.
Raw output
When comparing enums, `equals()` should be avoided and `==` should be preferred. Using `==` has some advantages: * same semantic as `equals()` * less problematic with possible null pointer exceptions * supports static type check: If you compare two incompatible enum types, the compiler will tell you. When using equals, you'll only get noticed at runtime or not at all. This rule implements SonarSource rule [S4551](https://sonarsource.github.io/rspec/#/rspec/S4551). Note, that only primitive types and enums should be compared using `==`. To compare other objects, `equals()` is the correct way. See {%rule java/errorprone/CompareObjectsWithEquals %} and {%rule java/errorprone/UseEqualsToCompareStrings %}. <pre> <code> enum Color { RED, GREEN, BLUE } class ColorTester { boolean isRed(Color color) { return color.equals(Color.RED); // violation } boolean isGreen(Color color) { return color == Color.GREEN; // preferred } } </code> </pre> <a href="https://docs.pmd-code.org/pmd-doc-7.19.0/pmd_rules_java_bestpractices.html#enumcomparison"> See PMD documentation. </a>
Loading