Spotbugs Maven Plugin

https://github.com/spotbugs/spotbugs-maven-plugin
Admin
Maven Mojo Plug-In to generate reports based on the SpotBugs Analyzer.
Tokens:12,269
Snippets:66
Trust Score:9.2
License:Apache-2.0
Update:1 month ago
Show doc for...
Tokens:
Raw
### AbstractMissingHashCode example with SpotBugs annotations

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/AbstractMissingHashCode.html

Example for SpotBugs annotations demonstrating equals/hashCode contract violations. Shows @ExpectWarning for HE_EQUALS_USE_HASHCODE, HE_INHERITS_EQUALS_USE_HASHCODE, EQ_UNUSUAL, and EQ_DOESNT_OVERRIDE_EQUALS, and @NoWarning for HE when hashCode is overridden.

```java
import edu.umd.cs.findbugs.annotations.ExpectWarning;
import edu.umd.cs.findbugs.annotations.NoWarning;

abstract class AbstractMissingHashCode {
    int x;

    @Override
    @ExpectWarning("HE_EQUALS_USE_HASHCODE")
    public boolean equals(Object o) {
        if (!(o instanceof AbstractMissingHashCode))
            return false;
        return x == ((AbstractMissingHashCode) o).x;
    }

    @ExpectWarning("HE_INHERITS_EQUALS_USE_HASHCODE")
    static class StillMissingHashCode extends AbstractMissingHashCode {
        int y;
    }

    static class Concrete extends StillMissingHashCode {
        public int z;

        @Override
        @NoWarning("HE")
        public int hashCode(){
            return 0;
        }

        @ExpectWarning("EQ_UNUSUAL")
        @Override
        public boolean equals(Object o) {
            // #303 Request for check <int var> += <double val>
            int sum = 5;
            sum += 4.2; // same as sum = (int)(sum + 4.2);
            System.out.println(sum);
            return o == this;
        }
    }

    @ExpectWarning("EQ_DOESNT_OVERRIDE_EQUALS")
    static class ConcreteMissingEquals extends Concrete {
        int z;
    }
}
```

--------------------------------

### App.java - SpotBugs Maven Plugin integration test example

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref-test/org/codehaus/mojo/spotbugsmavenplugin/it/App.html

The App class is a simple Java example used for integration testing of the SpotBugs Maven Plugin. It includes a private constructor to prevent instantiation, a main method that logs "Hello World!", and a clone method that returns null without calling super.clone(), which is a deliberate SpotBugs issue.

```java
1   /*
2    * Copyright 2005-2026 the original author or authors.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     https://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  package org.codehaus.mojo.spotbugsmavenplugin.it;
17
18  import java.util.Objects;
19
20  import org.slf4j.Logger;
21  import org.slf4j.LoggerFactory;
22
23  /**
24   * Hello world!
25   */
26  public class App implements Cloneable {
27
28      private static final Logger logger = LoggerFactory.getLogger(App.class);
29
30      private App() {
31          // Do not allow instantiation
32      }
33
34      public static void main(String[] args) {
35          Objects.isNull(args);
36          logger.info("Hello World!");
37      }
38
39      public Object clone() {
40          return null; // Does not call 'super.clone()'.
41      }
42
43  }
```

--------------------------------

### AssumeUnsignedBytes class example

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/AssumeUnsignedBytes.html

This example demonstrates a common bug where a byte array is compared against an integer value, potentially triggering an INT warning in FindBugs/SpotBugs.

```java
1   import edu.umd.cs.findbugs.annotations.ExpectWarning;
2
3   class AssumeUnsignedBytes {
4
5       @ExpectWarning("INT")
6       int find200(byte[] b) {
7           for (int i = 0; i < b.length; i++)
8               if (b[i] == 200)
9                   return i;
10          return -1;
11      }
12  }
```

--------------------------------

### UseInitCause.java - Demonstrates initCause for RuntimeException

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UseInitCause.html

This example shows how to wrap an IOException in a RuntimeException and set the original exception as the cause using initCause. The method firstLine reads a line from a BufferedReader and throws a RuntimeException with the message "IO Error" and the caught IOException as its cause.

```java
import java.io.BufferedReader;
import java.io.IOException;

public class UseInitCause {

    public String firstLine(BufferedReader r) {
        try {
            return r.readLine();
        } catch (IOException e) {
            throw (RuntimeException) new RuntimeException("IO Error").initCause(e);
        }
    }

}
```

--------------------------------

### UserMistakes.java - Java example with intentional mistakes

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UserMistakes.html

Java class demonstrating common mistakes: replaceAll with regex '.' matches any character, indexOf check uses >0 instead of >=0, and resource handling issues with BufferedReader and LineNumberReader. The @ExpectWarning annotation expects warnings for RE and RV categories.

```java
1
2   import java.io.BufferedReader;
3   import java.io.FileNotFoundException;
4   import java.io.FileReader;
5   import java.io.IOException;
6   import java.io.LineNumberReader;
7
8   import edu.umd.cs.findbugs.annotations.ExpectWarning;
9
10  public class UserMistakes {
11      @ExpectWarning("RE,RV")
12      public static void main(String[] args) throws IOException {
13          String name = "Mr. Ed";
14          name = name.replaceAll(".", "s.");
15          System.out.println(name);
16
17          // FIXME:FindBugs only catches this error with name.indexOf(String)
18          if (name.indexOf("s") > 0)
19              System.out.println("Yay");
20          else
21              System.out.println("Boo");
22
23          String result;
24
25          try {
26              BufferedReader findFiles = new BufferedReader(new FileReader("/mainList.txt"));
27              if (findFiles.readLine() != null)
28                  result = findFiles.readLine();
29              findFiles.close();
30          } catch (FileNotFoundException e) {
31              System.exit(7);
32              e.printStackTrace();
33          } catch (IOException e) {
34              e.printStackTrace();
35          }
36
37          LineNumberReader tmp = new LineNumberReader(new FileReader("/mainList.txt"));
38          int count = 0;
39          while (tmp.readLine() != null)
40              count++;
41
42          tmp.close();
43      }
44
45  }
```

--------------------------------

### ArgumentAssertions class with assertion examples

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/ArgumentAssertions.html

Full Java class showing various assertion patterns for SpotBugs testing. The class contains methods that should fail the detection and a few that should pass, including methods using literal assertions and conditional messages.

```java
public class ArgumentAssertions {
    // Should fail
    public static int getAbsAdd(int x, int y) {
        assert x != Integer.MIN_VALUE;
        assert y != Integer.MIN_VALUE;
        int absX = Math.abs(x);
        int absY = Math.abs(y);
        assert (absX <= Integer.MAX_VALUE - absY);
        return absX + absY;
    }

    // Should fail
    public static int getAbsAdd2(int x, int y) {
        assert Math.abs(x) != Integer.MIN_VALUE;
        assert y != Integer.MIN_VALUE;
        int absX = Math.abs(x);
        int absY = Math.abs(y);
        assert (absX <= Integer.MAX_VALUE - absY);
        return absX + absY;
    }

    private static int plus1(int x) {
        return x + 1;
    }

    // Should fail
    public static int getAbsAdd3(int x, int y) {
        assert Math.abs(x) != Integer.MIN_VALUE;
        assert plus1(y) != Integer.MIN_VALUE;
        assert Math.abs(plus1(y)) != Integer.MIN_VALUE;
        int absX = Math.abs(x);
        int absY = Math.abs(y);
        assert (absX <= Integer.MAX_VALUE - absY);
        return absX + absY;
    }

    // Should fail
    public static int getAbsAdd4(int x, int y) {
        assert Math.abs(plus1(y)) != Integer.MIN_VALUE;
        int absX = Math.abs(x);
        int absY = Math.abs(y);
        return absX + absY;
    }

    // Should fail
    public static Object print(Object x) {
        assert x != null;
        Double f = 3.0;
        System.out.println(f.toString());
        return x;
    }

    private static String helper(String s) {
        return s;
    }

    // Should fail
    public static void indirect(String s) {
        assert helper(s) == null : "This is not a false pos" + s;
    }

    // Should fail
    public static boolean compBool1(boolean b) {
        assert b == true;
        return b;
    }

    // Should fail
    public static boolean compBool2(boolean b) {
        assert b;
        return b;
    }

    // Should fail
    public static int getAbs(byte x) {
        assert Math.abs(x) != Integer.MIN_VALUE;
        int absX = Math.abs(x);
        return absX;
    }

    // Should fail
    public static int getAbs(short x) {
        assert Math.abs(x) != Integer.MIN_VALUE;
        int absX = Math.abs(x);
        return absX;
    }

    // Should fail
    public static int compShor(short s) {
        assert s == 0;
        return s;
    }

    // Should fail
    public static long getAbs(long x) {
        assert Math.abs(x) != Integer.MIN_VALUE;
        long absX = Math.abs(x);
        return absX;
    }

    // Should fail
    public static long compLong(long l) {
        assert l == 0;
        return l;
    }

    // Should fail
    public static float getAbs(float x) {
        assert Math.abs(x) != Integer.MIN_VALUE;
        float absX = Math.abs(x);
        return absX;
    }

    // Should fail
    public static float compFloat(float f) {
        assert f < 0;
        return f;
    }

    // Should fail
    public static double getAbs(double x) {
        assert Math.abs(x) != Integer.MIN_VALUE;
        double absX = Math.abs(x);
        return absX;
    }

    // Should fail
    public static double compDouble(double d) {
        assert d > 0;
        return d;
    }

    // Should fail
    public static boolean indirect(boolean b) {
        boolean l = b;
        assert l;
        return l;
    }

    // Should fail, but passes because indirect assertions of arguments are not supported yet (except copies)
    public static boolean indirect2(boolean b) {
        boolean l = !b;
        assert l;
        return l;
    }

    // Should pass
    public static String literal(String s) {
        assert false;
        return s;
    }

    // Should pass
    public static boolean literalAndMessage(boolean b) {
        assert false : b;
        return b;
    }

    // Should pass
    public static String literalAndMessageStr(String s) {
        assert false : s;
        return s;
    }

    // Should pass
    public static void conditionallyInMessage(int x, String s) {
        if (x < 0) {
            assert false : "This is a false pos" + s;
        }
    }

    // helper method
    public void helper() {
        privateMethod(1);
        privateFinalMethod(1);
        privateStaticMethod(0);
    }
}
```

--------------------------------

### UselessControlFlow example class

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UselessControlFlow.html

Example class for the UselessControlFlow bug pattern. The harmless1 method has an if-else with empty blocks, which is not flagged. The report0 through report3 methods use an if statement with an empty statement (semicolon) as the body, which is flagged as useless control flow. The report4 method has an empty if block inside a for loop, also flagged. The line numbers in the source are not part of the code.

```java
public class UselessControlFlow {

    void harmless1(Object x, Object y) {
        if (!x.equals(y)) {

        } else {

        }
        System.out.println(x);
        System.out.println(y);
    }

    void report0(Object x, Object y) {
        if (!x.equals(y))
            ;
        System.out.println(x);
        System.out.println(y);
    }

    void report1(Object x, Object y) {
        if (!x.equals(y))
            ;
        System.out.println(x);
        System.out.println(y);
    }

    void report2(Object x, Object y) {
        if (!x.equals(y))
            ;

        System.out.println(x);
        System.out.println(y);
    }

    void report3(Object x, Object y) {
        if (!x.equals(y))
            ;

        System.out.println(x);
        System.out.println(y);
    }

    void report4(Object[] x, Object y) {
        for (Object o : x) {
            if (o.equals(y)) {
            }
        }
    }
}
```

--------------------------------

### Private Method Assertions

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/ArgumentAssertions.html

Examples of private methods where assertions on arguments are considered valid.

```java
private void privateMethod(int x) {
        assert x != 0;
    }
```

```java
private final void privateFinalMethod(int x) {
        assert x != 0;
    }
```

```java
private static void privateStaticMethod(int x) {
        assert x == 0;
    }
```

--------------------------------

### UselessFinalize class with useless finalize() override

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UselessFinalize.html

Shows a Java class that overrides finalize() to only call super.finalize(), which is useless. Use this as an example of a finalize() override that does nothing useful.

```java
class UselessFinalize {
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }
}
```

--------------------------------

### UselessAssignments example with SpotBugs @ExpectWarning annotations

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UselessAssignments.html

Complete Java class demonstrating useless assignments that trigger SpotBugs warnings UR, UrF, UuF, DLS, and SA. The class includes fields annotated with @ExpectWarning, a constructor with self-assignments, static methods with chained assignments, and methods that increment fields in ways that produce useless assignments. The doNotReport method shows an assignment that is not flagged.

```java
1   import edu.umd.cs.findbugs.annotations.ExpectWarning;
2
3   class UselessAssignments {
4       @ExpectWarning("UR")
5       int foo;
6
7       @ExpectWarning("UrF")
8       int bar, g1;
9
10      @ExpectWarning("UuF")
11      int g2;
12
13      @ExpectWarning("DLS,SA")
14      public UselessAssignments(int Foo, int Bar) {
15          int x, y;
16          foo = foo;
17          Bar = Bar;
18          g1 = g1 = 0;
19          x = x = 0;
20      }
21
22      static void setFoo(UselessAssignments ua1, UselessAssignments ua2) {
23          ua1.foo = ua2.foo = 1;
24          ua1.bar = ua1.bar = ua1.bar = 2;
25      }
26
27      int oops() {
28          int i = 7;
29          i = ++i;
30          i = i++;
31          foo = foo++;
32          foo = ++foo;
33          return i;
34      }
35
36      public static void report(UselessAssignments ua1, UselessAssignments ua2) {
37          ua1.foo = ua1.foo = ua1.foo = 17;
38      }
39
40      public static void doNotReport(UselessAssignments ua1, UselessAssignments ua2) {
41          ua1.bar = ua2.bar = 42;
42      }
43
44  }
```

--------------------------------

### UselessSCMethods example: subclass methods that only call super

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UselessSCMethods.html

Shows a superclass with several methods and a subclass that overrides each method by only calling the superclass version. The overridden test4 is commented as not reported because access has been widened, and the comment suggests it might be another bug type.

```java
class Super {
    public void test1() {
    }

    public int test2(String s) {
        return 1;
    }

    public double test3(double d, int i, Object o, float f, long l) {
        return 0.0;
    }

    protected void test4(String s) {
    }

    public void test5(String[] s) {
    }
}

public class UselessSCMethods extends Super {
    @Override
    public void test1() {
        super.test1();
    }

    @Override
    public int test2(String s) {
        return super.test2(s);
    }

    @Override
    public double test3(double d, int i, Object o, float f, long l) {
        return super.test3(d, i, o, f, l);
    }

    @Override
    public void test4(String s) { // don't report this, although suspect, access
                                  // has been widened
        // perhaps this should be reported as another bug type, dunno
        super.test4(s);
    }

    @Override
    public void test5(String[] s) {
        super.test5(s);
    }
}
```

--------------------------------

### Public Method Assertions in Loops

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/ArgumentAssertions.html

Examples of public methods where assertions on arguments within loops or streams are flagged as failures.

```java
public static void assertingArgInFor(String prefix) {
        java.util.List<String> strings = new java.util.ArrayList<>();
        for (String s : strings) {
            assert s.startsWith(prefix);
        }
    }
```

```java
public static void assertingArgInStream(String prefix) {
        java.util.List<String> strings = new java.util.ArrayList<>();
        strings.forEach(s -> {
            assert s.startsWith(prefix);
        });
    }
```

--------------------------------

### UserAss3rtion class implementation

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UserAss3rtion.html

A utility class providing a static assertion method to throw an IllegalStateException if a condition is false, demonstrated with a usage example in method f.

```java
1   public class UserAss3rtion {
2       public static void makeSureItIsOK(boolean cond) {
3           if (!cond)
4               throw new IllegalStateException();
5       }
6
7       public void f(Object o) {
8           UserAss3rtion.makeSureItIsOK(o != null);
9           System.out.println(o.hashCode());
10      }
11  }
```

--------------------------------

### AccidentalNonConstructorInInnerClass Java Example

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/AccidentalNonConstructorInInnerClass.html

A Java class demonstrating methods that resemble constructors within inner classes, which can lead to confusion or bugs.

```java
1   public class AccidentalNonConstructorInInnerClass {
2
3       class Report {
4           void Report() {
5           };
6
7           class DeeplyNested {
8               void DeeplyNested() {
9               };
10          }
11      }
12
13      static class Report2 {
14          void Report2() {
15          };
16      }
17
18      class DoNotReport {
19          @Deprecated
20          void DoNotReport() {
21          }
22
23          DoNotReport() {
24          }
25      }
26
27      static class DoNotReport2 {
28          void DoNotReport2() {
29              throw new UnsupportedOperationException();
30          }
31
32          DoNotReport2() {
33          }
34      }
35
36  }
```

--------------------------------

### Run SpotBugs GUI with specific version

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Launches the SpotBugs GUI using the specified plugin version. The ${spotbugs.plugin} placeholder is replaced with the desired version.

```bash
mvn com.github.spotbugs:spotbugs-maven-plugin:${spotbugs.plugin}:gui
```

--------------------------------

### Run integration tests with Maven

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Runs the integration tests for the SpotBugs Maven plugin. Requires the run-its profile and sets the test source to remote.

```bash
mvn clean install -P run-its -DtestSrc=remote
```

--------------------------------

### Run all tests with remote test source

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Runs all integration tests using the remote SpotBugs test source. This is the preferred way to run the full test suite.

```bash
mvn -DtestSrc=remote -Prun-its clean install -D"invoker.parallelThreads=8"
```

--------------------------------

### Run tests with local SpotBugs test source

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Runs tests using a local copy of the SpotBugs test source code instead of fetching it from the GitHub repository. The local path is specified with -DlocalTestSrc.

```bash
mvn -DtestSrc=local -DlocalTestSrc=/opt/spotBugs -Prun-its clean install -D"invoker.parallelThreads=8"
```

--------------------------------

### Run reproducibility check against official release

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Run reproducibility checks against an official release. Best to check out the specific release tag first and ensure Maven and JDK versions match what was used for that release.

```bash
mvn clean verify artifact:compare -D"reference.repo=https://repo.maven.apache.org/maven2/"
```

--------------------------------

### Validate reproducibility locally with two-step loop

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Validate reproducibility locally on your current branch before a release. Uses local .m2 cache as reference baseline without overwriting it on the second pass.

```bash
mvn clean install
mvn clean verify artifact:compare -D"reference.repo=file:///${user.home}/.m2/repository/"
```

--------------------------------

### Java class demonstrating appending to ObjectOutputStream with @ExpectWarning annotations

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/AppendingToAnObjectOutputStream.html

Defines the AppendingToAnObjectOutputStream class with four methods that append to an ObjectOutputStream, using either a plain FileOutputStream or a BufferedOutputStream wrapper, and either a File or a String path. Each method is annotated with @ExpectWarning("IO") to indicate the expected warning.

```java
1   import java.io.BufferedOutputStream;
2   import java.io.File;
3   import java.io.FileNotFoundException;
4   import java.io.FileOutputStream;
5   import java.io.IOException;
6   import java.io.ObjectOutputStream;
7
8   import edu.umd.cs.findbugs.annotations.ExpectWarning;
9
10  public class AppendingToAnObjectOutputStream {
11
12      @ExpectWarning("IO")
13      public static void appendObject1(File f, Object o) throws FileNotFoundException, IOException {
14          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f, true));
15          out.writeObject(o);
16          out.close();
17      }
18
19      @ExpectWarning("IO")
20      public static void appendObject2(File f, Object o) throws FileNotFoundException, IOException {
21          ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(f, true)));
22          out.writeObject(o);
23          out.close();
24      }
25
26      @ExpectWarning("IO")
27      public static void appendObject3(String f, Object o) throws FileNotFoundException, IOException {
28          ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f, true));
29          out.writeObject(o);
30          out.close();
31      }
32
33      @ExpectWarning("IO")
34      public static void appendObject4(String f, Object o) throws FileNotFoundException, IOException {
35          ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(f, true)));
36          out.writeObject(o);
37          out.close();
38      }
39  }
```

--------------------------------

### Skip tests during build

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Skips running tests during the build.

```bash
mvn -DskipTests=true clean install
```

--------------------------------

### Run tests in debugger

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Runs tests with the debugger enabled, listening on port 8000. The -Dmaven.surefire.debug property configures the JVM debug arguments.

```bash
mvn -Dmaven.surefire.debug="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 -Xnoagent -Djava.compiler=NONE" -Prun-its clean install
```

--------------------------------

### Run selected integration tests

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Runs only the selected integration tests. The -Dinvoker.test property accepts a comma-separated list of test patterns.

```bash
mvn -DtestSrc=remote -Prun-its -Dinvoker.test=build-*,basic-1,check-nofail clean install -D"invoker.parallelThreads=8"
```

--------------------------------

### ArrayToString class demonstration

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/ArrayToString.html

A Java class containing methods that trigger USELESS_STRING, DMI_INVOKING_TOSTRING_ON_ANONYMOUS_ARRAY, and DMI_INVOKING_TOSTRING_ON_ARRAY warnings by calling toString() on various array types.

```java
1   import edu.umd.cs.findbugs.annotations.DesireWarning;
2
3   public class ArrayToString {
4
5       private static final String[] gargs = new String[] { "1", "2" };
6
7       public static void main(String[] args) {
8           ArrayToString a = new ArrayToString();
9           a.print0(args);
10          a.print1();
11          a.print2();
12          a.print3();
13      }
14
15      @DesireWarning("USELESS_STRING")
16      public void print0(String args[]) {
17          System.out.println(args.toString());
18      }
19
20      @DesireWarning("USELESS_STRING")
21      public void print1() {
22          String[] args2 = new String[] { "Hello", "there" };
23          System.out.println(args2.toString());
24      }
25
26      @DesireWarning("DMI_INVOKING_TOSTRING_ON_ANONYMOUS_ARRAY")
27      public void print2() {
28          System.out.println((new String[] { "one", "two" }).toString());
29      }
30
31      @DesireWarning("DMI_INVOKING_TOSTRING_ON_ARRAY")
32      public void print3() {
33          System.out.println(gargs.toString());
34      }
35  }
```

--------------------------------

### AnnotationTest.java with @CheckReturnValue

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/AnnotationTest.html

Defines a class with a method annotated with @CheckReturnValue(confidence = Confidence.HIGH). The annotation is from the SpotBugs annotations library.

```java
import edu.umd.cs.findbugs.annotations.CheckReturnValue;
import edu.umd.cs.findbugs.annotations.Confidence;

class AnnotationTest {
    @CheckReturnValue(confidence = Confidence.HIGH)
    int f() {
        return 42;
    }
}
```

--------------------------------

### Java class A with main method using String.replace

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/A.html

A simple Java class with a main method that replaces all occurrences of "x" with "y" in the first command-line argument and prints the result.

```java
1   class A {
2       public static void main(String args[]) {
3           System.out.println(args[0].replace("x", "y"));
4       }
5   }
```

--------------------------------

### Set analysis property via jvmArgs in Maven plugin configuration

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Configures the SpotBugs Maven plugin to pass a Java system property as a JVM argument, setting the findbugs.assertionmethods analysis property. This is the recommended way to set analysis properties in the plugin configuration.

```xml
<plugin>
    <groupId>com.github.spotbugs</groupId>
    <artifactId>spotbugs-maven-plugin</artifactId>
    <configuration>
        <jvmArgs>-Dfindbugs.assertionmethods=org.apache.commons.lang3.Validate.notNull</jvmArgs>
    </configuration>
</plugin>
```

--------------------------------

### Run selected tests in debugger

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Runs selected tests in debugger mode. Combines the debugger configuration with the -Dinvoker.test filter to debug only specific tests.

```bash
mvn -Dmaven.surefire.debug="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000 -Xnoagent -Djava.compiler=NONE" -Prun-its -Dinvoker.test=build-*,basic-1,check clean install
```

--------------------------------

### UselessCurrentThread.java - SpotBugs detector test class

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UselessCurrentThread.html

Java class implementing Runnable that tests the SuspiciousThreadInterrupted detector. It includes methods with @NoWarning, @ExpectWarning, and @DesireWarning annotations to verify SpotBugs behavior on various Thread.interrupted() calls. Note that test4 and test5 have comments indicating no warning with the ecj (Eclipse) compiler.

```java
import annotations.DetectorUnderTest;
import edu.umd.cs.findbugs.annotations.DesireWarning;
import edu.umd.cs.findbugs.annotations.ExpectWarning;
import edu.umd.cs.findbugs.annotations.NoWarning;
import edu.umd.cs.findbugs.detect.SuspiciousThreadInterrupted;

@DetectorUnderTest(SuspiciousThreadInterrupted.class)
public class UselessCurrentThread implements Runnable {
    private Thread unknownThread;

    public UselessCurrentThread(Thread t) {
        unknownThread = t;
    }

    @NoWarning("STI_INTERRUPTED_ON_CURRENTTHREAD")
    void test1() throws InterruptedException {
        while (!Thread.interrupted()) {
            System.out.println("huh?");
            Thread.sleep(10000);
        }
    }

    void test2() throws InterruptedException {
        Thread.currentThread();
        while (!Thread.interrupted()) {
            System.out.println("huh?");
            Thread.sleep(10000);
        }
    }

    @ExpectWarning("STI_INTERRUPTED_ON_CURRENTTHREAD")
    void test3() throws InterruptedException {
        while (!Thread.currentThread().interrupted()) {
            System.out.println("huh?");
            Thread.sleep(10000);
        }
    }

    // XXX no warning with ecj (Eclipse) compiler (bad)
    @DesireWarning("STI_INTERRUPTED_ON_UNKNOWNTHREAD")
    void test4() throws InterruptedException {
        Thread t = Thread.currentThread();
        while (!unknownThread.interrupted()) {
            System.out.println("huh?");
            Thread.sleep(10000);
        }
    }

    // XXX no warning with ecj (Eclipse) compiler (bad)
    @DesireWarning("STI_INTERRUPTED_ON_UNKNOWNTHREAD")
    void test5() throws InterruptedException {
        while (!unknownThread.interrupted()) {
            System.out.println("huh?");
            Thread.sleep(10000);
        }
    }

    @Override
    public void run() {
        try {

            test1();
            test2();
            test3();
            test4();

        } catch (InterruptedException ie) {
            System.out.println("Oh, ok");
        }
    }
}
```

--------------------------------

### AssertionsWithSideEffects.java - Java class with assertion side effects

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/AssertionsWithSideEffects.html

Complete Java class demonstrating assertions with side effects. Includes methods that increment a variable inside an assert, assign boolean values in assert, modify a list in assert, and use an immutable list with an add operation in assert. Useful for testing static analysis tools that detect side effects in assertions.

```java
1   import java.util.ArrayList;
2   import java.util.List;
3
4   public class AssertionsWithSideEffects {
5       public static int iinc(int x) {
6           assert x++ == 0;
7           return x;
8       }
9
10      public static boolean storeBoolean(boolean b) {
11          boolean y = false;
12          assert y = b == true;
13          return y;
14      }
15
16      public static boolean storeInt(int n) {
17          boolean y = false;
18          assert y = (n == 1);
19          return y;
20      }
21
22      private static List<String> list = new ArrayList<String>();
23
24      public static void addAndRemove() {
25          list.add("a");
26          assert list.remove(null);
27      }
28
29      public static void addAndCheckEmptiness() {
30          list.add("a");
31          assert !list.isEmpty();
32      }
33
34      // A sample immutable class with an "add" operation
35      private static class ImmutableList<Element> {
36          Object[] elements;
37
38          public ImmutableList() {
39              elements = new Object[0];
40          }
41
42          private ImmutableList(Object[] array, Element e) {
43              elements = new Object[array.length + 1];
44              System.arraycopy(array, 0, elements, 0, array.length);
45              elements[array.length] = e;
46          }
47
48          // Does not mutate the current object but creates a new one
49          public ImmutableList<Element> add(Element e) {
50              return new ImmutableList<Element>(elements, e);
51          }
52
53          public boolean isEmpty() {
54              return elements.length == 0;
55          }
56      }
57
58      private static ImmutableList<String> il = new ImmutableList<>();
59
60      public static void add() {
61          assert !il.add("a").isEmpty();
62      }
63  }
```

--------------------------------

### DetectorUnderTest annotation source code

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/annotations/DetectorUnderTest.html

Defines the DetectorUnderTest annotation with a value of type Class<? extends Priorities>[] and retention policy SOURCE. It is used for documentation only.

```java
package annotations;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import edu.umd.cs.findbugs.Priorities;

/**
 * This annotation documents to which detector(s) annotated test samples are linked.
 * Currently it is used for documentation only.
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.SOURCE)
@Documented
public @interface DetectorUnderTest {
    Class<? extends Priorities> [] value();
}
```

--------------------------------

### FooTest.java - JUnit 5 test class with @Test and @Disabled

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref-test/org/codehaus/mojo/spotbugsmavenplugin/it/FooTest.html

Defines the FooTest class with two test methods: thisAlwaysPasses (enabled) and thisIsIgnored (annotated with @Disabled). The class is in package org.codehaus.mojo.spotbugsmavenplugin.it and imports org.junit.jupiter.api.Test and org.junit.jupiter.api.Disabled.

```java
/*
 * Copyright 2005-2026 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.codehaus.mojo.spotbugsmavenplugin.it;


import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Disabled;

/**
 * Tests for {@link Foo}.
 *
 * @author user@example.com (John Doe)
 */
class FooTest {

    @Test
    void thisAlwaysPasses() {
        // Do nothing
    }

    @Disabled
    @Test
    void thisIsIgnored() {
        // Do nothing
    }
}
```

--------------------------------

### Override SpotBugs version in Maven plugin

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/README.md

Add this plugin configuration to your pom.xml to override the SpotBugs version used by the Maven plugin. Replace the version placeholders with your desired versions.

```xml
    <plugin>
        <groupId>com.github.spotbugs</groupId>
        <artifactId>spotbugs-maven-plugin</artifactId>
        <version>${spotbugs-maven-plugin.version}</version>
        <dependencies>
            <dependency>
                <groupId>com.github.spotbugs</groupId>
                <artifactId>spotbugs</artifactId>
                <version>${spotbugs.version}</version>
            </dependency>
        </dependencies>
    </plugin>
```

--------------------------------

### UseOfNonHashableClassInHashDataStructure implementation

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/UseOfNonHashableClassInHashDataStructure.html

A class definition showing the usage of HashMap with a custom class that overrides equals but lacks a proper hashCode implementation.

```java
1   import java.util.HashMap;
2
3   public class UseOfNonHashableClassInHashDataStructure {
4
5       static class UMap extends HashMap<UseOfNonHashableClassInHashDataStructure, String> {
6       };
7
8       static HashMap<UseOfNonHashableClassInHashDataStructure, String> m = new HashMap<UseOfNonHashableClassInHashDataStructure, String>();
9
10      static int foo(HashMap<UseOfNonHashableClassInHashDataStructure, String> map) {
11          return map.size();
12      }
13
14      @Override
15      public boolean equals(Object o) {
16          return hashCode() == o.hashCode();
17      }
18
19      public static String add(UseOfNonHashableClassInHashDataStructure b, String s) {
20          return m.put(b, s);
21      }
22
23      public static String get(UseOfNonHashableClassInHashDataStructure b) {
24          return m.get(b);
25      }
26  }
```

--------------------------------

### AssignedOnlyInCtor class source

Source: https://github.com/spotbugs/spotbugs-maven-plugin/blob/master/src/site/resources/examples/xref/AssignedOnlyInCtor.html

Source code for the AssignedOnlyInCtor class. The field 'value' is assigned only in the constructor, and a getter method is provided.

```java
public class AssignedOnlyInCtor {
    private int value;

    public AssignedOnlyInCtor(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

}
```
Tokens:
Raw