From 3722f902e7f64d047184ba4d43aabe61f1ef3556 Mon Sep 17 00:00:00 2001
From: gonczmisi <gonczmisi@gmail.com>
Date: Tue, 10 May 2022 00:02:52 +0200
Subject: [PATCH 1/8] Introduced detector for rule VNA-00 and VNA-02 with test
 cases

---
 CHANGELOG.md                                  |   2 +
 ...ibilityOnSharedPrimitiveVariablesTest.java | 100 +++++++++
 ...mpoundOperationsOnSharedVariablesTest.java | 207 ++++++++++++++++++
 spotbugs/etc/findbugs.xml                     |   6 +
 spotbugs/etc/messages.xml                     |  56 +++++
 ...dVisibilityOnSharedPrimitiveVariables.java | 158 +++++++++++++
 .../CompoundOperationsOnSharedVariables.java  | 207 ++++++++++++++++++
 .../MultiThreadedCodeIdentifierUtils.java     | 106 +++++++++
 ...poundAdditionOnSharedVolatileVariable.java |  13 ++
 .../CompoundDivisionOnSharedVariable.java     |  13 ++
 ...CompoundIANDOperationOnSharedVariable.java |  13 ++
 .../CompoundIOROperationOnSharedVariable.java |  13 ++
 .../CompoundLeftShiftingOnSharedVariable.java |  17 ++
 ...dLogicalRightShiftingOnSharedVariable.java |  13 ++
 .../CompoundModuloOnSharedVariable.java       |  14 ++
 ...ompoundMultiplicationOnSharedVariable.java |  13 ++
 ...mpoundOperationOnSharedAtomicVariable.java |  15 ++
 ...undPostDecrementationOnSharedVariable.java |  13 ++
 ...undPostIncrementationOnSharedVariable.java |  13 ++
 ...oundPreDecrementationOnSharedVariable.java |  13 ++
 ...oundPreIncrementationOnSharedVariable.java |  13 ++
 ...CompoundRightShiftingOnSharedVariable.java |  19 ++
 .../CompoundSubtractionOnSharedVariable.java  |  13 ++
 .../CompoundXOROperationOnSharedVariable.java |  13 ++
 ...lockCompoundOperationOnSharedVariable.java |  15 ++
 ...thodCompoundOperationOnSharedVariable.java |  13 ++
 .../sharedPrimitiveVariables/AtomicField.java |  21 ++
 .../FieldWithBadVisibilityRunnable.java       |  20 ++
 .../FieldWithBadVisibilityThread.java         |  20 ++
 .../SynchronizedBlock.java                    |  22 ++
 ...chronizedBlockAndBadVisibilityOnField.java |  25 +++
 .../SynchronizedMethod.java                   |  20 ++
 ...hronizedMethodAndBadVisibilityOnField.java |  23 ++
 .../VolatileField.java                        |  19 ++
 34 files changed, 1261 insertions(+)
 create mode 100644 spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
 create mode 100644 spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
 create mode 100644 spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
 create mode 100644 spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
 create mode 100644 spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/AtomicField.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlock.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethod.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
 create mode 100644 spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/VolatileField.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e2a0e90dffb..95e0e24826f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,8 @@ This is the changelog for SpotBugs. This follows [Keep a Changelog v1.0.0](http:
 Currently the versioning policy of this project follows [Semantic Versioning v2.0.0](http://semver.org/spec/v2.0.0.html).
 
 ## Unreleased - 2022-??-??
+### Added
+* New detector `BadVisibilityOnSharedPrimitiveVariables` for new bug type `SPV_BAD_VISIBILITY_ON_SHARED_PRIMITIVE_VARIABLES` (See [SEI CERT rule VNA00-J](https://wiki.sei.cmu.edu/confluence/display/java/VNA00-J.+Ensure+visibility+when+accessing+shared+primitive+variables))
 
 ## 4.7.0 - 2022-04-14
 ### Changed
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
new file mode 100644
index 00000000000..1e98288d5a6
--- /dev/null
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
@@ -0,0 +1,100 @@
+package edu.umd.cs.findbugs.detect;
+
+import edu.umd.cs.findbugs.AbstractIntegrationTest;
+import edu.umd.cs.findbugs.SystemProperties;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+import org.junit.Test;
+
+import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasItem;
+
+public class BadVisibilityOnSharedPrimitiveVariablesTest extends AbstractIntegrationTest {
+
+    @Test
+    public void failurePath_fieldWithBadVisibility_whenOtherMethodHasSynchronizedBlock() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.class");
+
+        assertSPVNumOfBugs(1);
+        assertSPVBug("SynchronizedBlockAndBadVisibilityOnField", "shutdown", 18);
+    }
+
+    @Test
+    public void failurePath_fieldWithBadVisibility_whenOtherMethodIsSynchronized() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.class");
+
+        assertSPVNumOfBugs(1);
+        assertSPVBug("SynchronizedMethodAndBadVisibilityOnField", "shutdown", 18);
+    }
+
+    @Test
+    public void failurePath_fieldWithBadVisibility_whenClassExtendsThread() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.class");
+
+        assertSPVNumOfBugs(1);
+        assertSPVBug("FieldWithBadVisibilityThread", "shutdown", 19);
+    }
+
+    @Test
+    public void failurePath_fieldWithBadVisibility_whenClassImplementsRunnable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.class");
+
+        assertSPVNumOfBugs(1);
+        assertSPVBug("FieldWithBadVisibilityRunnable", "shutdown", 19);
+    }
+
+    @Test
+    public void happyPath_atomicField() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/sharedPrimitiveVariables/AtomicField.class");
+
+        assertSPVNumOfBugs(0);
+    }
+
+    @Test
+    public void happyPath_volatileField() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/sharedPrimitiveVariables/VolatileField.class");
+
+        assertSPVNumOfBugs(0);
+    }
+
+    @Test
+    public void happyPath_synchronizedBlock() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedBlock.class");
+
+        assertSPVNumOfBugs(0);
+    }
+
+    @Test
+    public void happyPath_synchronizedMethod() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedMethod.class");
+
+        assertSPVNumOfBugs(0);
+    }
+
+    private void assertSPVNumOfBugs(int num) {
+        final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType("SPV_BAD_VISIBILITY_ON_SHARED_PRIMITIVE_VARIABLES")
+                .build();
+        assertThat(getBugCollection(), containsExactly(num, bugTypeMatcher));
+    }
+
+    private void assertSPVBug(String className, String methodName, int line) {
+        final BugInstanceMatcher bugInstanceMatcher = new BugInstanceMatcherBuilder()
+                .bugType("SPV_BAD_VISIBILITY_ON_SHARED_PRIMITIVE_VARIABLES")
+                .inClass(className)
+                .inMethod(methodName)
+                .atLine(line)
+                .build();
+        assertThat(getBugCollection(), hasItem(bugInstanceMatcher));
+    }
+
+}
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
new file mode 100644
index 00000000000..a3b7d8d5b74
--- /dev/null
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
@@ -0,0 +1,207 @@
+package edu.umd.cs.findbugs.detect;
+
+import edu.umd.cs.findbugs.AbstractIntegrationTest;
+import edu.umd.cs.findbugs.SystemProperties;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
+import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+import org.junit.Test;
+
+import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
+import static org.hamcrest.Matchers.hasItem;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class FindCompoundOperationsOnSharedVariablesTest extends AbstractIntegrationTest {
+
+    @Test
+    public void happyPath_compoundOperation_onSharedAtomicVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.class");
+
+        assertCOSVNumOfBugs(0);
+    }
+
+    @Test
+    public void happyPath_compoundOperationInsideSynchronizedBlock_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(0);
+    }
+
+    @Test
+    public void happyPath_compoundOperationInsideSynchronizedMethod_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(0);
+    }
+
+    // --num
+    @Test
+    public void reportsBugFor_compoundPreDecrementation_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundPreDecrementationOnSharedVariable", "getNum", 11);
+    }
+
+    // num--
+    @Test
+    public void reportsBugFor_compoundPostDecrementation_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundPostDecrementationOnSharedVariable", "getNum", 11);
+    }
+
+    // ++num
+    @Test
+    public void reportsBugFor_compoundPreIncrementation_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundPreIncrementationOnSharedVariable", "getNum", 11);
+    }
+
+    // num++
+    @Test
+    public void reportsBugFor_compoundPostIncrementation_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundPostIncrementationOnSharedVariable", "getNum", 11);
+    }
+
+    // &=
+    @Test
+    public void reportsBugFor_compoundIAND_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundIANDOperationOnSharedVariable", "getNum", 11);
+    }
+
+    // |=
+    @Test
+    public void reportsBugFor_compoundIOR_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundIOROperationOnSharedVariable", "getNum", 11);
+    }
+
+    // >>>=
+    @Test
+    public void reportsBugFor_compoundLogicalRightShifting_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundLogicalRightShiftingOnSharedVariable", "getNum", 11);
+    }
+
+    // >>=
+    @Test
+    public void reportsBugFor_compoundRightShifting_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundRightShiftingOnSharedVariable", "getNum", 11);
+    }
+
+    // <<=
+    @Test
+    public void reportsBugFor_compoundLeftShifting_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundLeftShiftingOnSharedVariable", "getNum", 11);
+    }
+
+    // %=
+    @Test
+    public void reportsBugFor_compoundModulo_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundModuloOnSharedVariable", "getNum", 12);
+    }
+
+    // *=
+    @Test
+    public void reportsBugFor_compoundMultiplication_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundMultiplicationOnSharedVariable", "getNum", 11);
+    }
+
+    // /=
+    @Test
+    public void reportsBugFor_compoundDivision_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundDivisionOnSharedVariable", "getNum", 11);
+    }
+
+    // -=
+    @Test
+    public void reportsBugFor_compoundSubtraction_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundSubtractionOnSharedVariable", "getNum", 11);
+    }
+
+
+    // +=
+    @Test
+    public void reportsBugFor_compoundAddition_onSharedVolatileVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundAdditionOnSharedVolatileVariable", "getNum", 11);
+    }
+
+    // ^=
+    @Test
+    public void reportsBugFor_compoundXOROperation_onSharedVariable() {
+        SystemProperties.setProperty("ful.debug", "true");
+        performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.class");
+
+        assertCOSVNumOfBugs(1);
+        assertCOSVBug("CompoundXOROperationOnSharedVariable", "getFlag", 11);
+    }
+
+    private void assertCOSVNumOfBugs(int num) {
+        final BugInstanceMatcher bugTypeMatcher = new BugInstanceMatcherBuilder()
+                .bugType("COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES")
+                .build();
+        assertThat(getBugCollection(), containsExactly(num, bugTypeMatcher));
+    }
+
+    private void assertCOSVBug(String className, String methodName, int line) {
+        final BugInstanceMatcher bugInstanceMatcher = new BugInstanceMatcherBuilder()
+                .bugType("COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES")
+                .inClass(className)
+                .inMethod(methodName)
+                .atLine(line)
+                .build();
+        assertThat(getBugCollection(), hasItem(bugInstanceMatcher));
+    }
+}
diff --git a/spotbugs/etc/findbugs.xml b/spotbugs/etc/findbugs.xml
index 8d60497ae13..118d3133918 100644
--- a/spotbugs/etc/findbugs.xml
+++ b/spotbugs/etc/findbugs.xml
@@ -669,6 +669,10 @@
                     reports="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS"/>
           <Detector class="edu.umd.cs.findbugs.detect.FindPotentialSecurityCheckBasedOnUntrustedSource" speed="fast"
                     reports="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"/>
+          <Detector class="edu.umd.cs.findbugs.detect.BadVisibilityOnSharedPrimitiveVariables"
+                    reports="SPV_BAD_VISIBILITY_ON_SHARED_PRIMITIVE_VARIABLES"/>
+          <Detector class="edu.umd.cs.findbugs.detect.CompoundOperationsOnSharedVariables"
+                    reports="COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES"/>
             <!-- Bug Categories -->
            <BugCategory category="NOISE" hidden="true"/>
 
@@ -1286,4 +1290,6 @@
           <BugPattern abbrev="PERM" type="PERM_SUPER_NOT_CALLED_IN_GETPERMISSIONS" category="MALICIOUS_CODE" />
           <BugPattern abbrev="USC" type="USC_POTENTIAL_SECURITY_CHECK_BASED_ON_UNTRUSTED_SOURCE"
                     category="MALICIOUS_CODE"/>
+          <BugPattern abbrev="SPV" type="SPV_BAD_VISIBILITY_ON_SHARED_PRIMITIVE_VARIABLES" category="MT_CORRECTNESS" />
+          <BugPattern abbrev="COSV" type="COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES" category="MT_CORRECTNESS"/>
 </FindbugsPlugin>
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 249492647ba..a660f10b3f2 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1772,6 +1772,26 @@ factory pattern to create these objects.</p>
       ]]>
     </Details>
   </Detector>
+  <Detector class="edu.umd.cs.findbugs.detect.BadVisibilityOnSharedPrimitiveVariables">
+    <Details>
+      <![CDATA[
+              <p>
+                Detector for patterns where a shared primitive variable in one thread
+                may not yield the value of the most recent write to the variable from another thread.
+                Consequently, the thread may observe a stale value of the shared variable.
+              </p>
+        ]]>
+    </Details>
+  </Detector>
+  <Detector class="edu.umd.cs.findbugs.detect.CompoundOperationsOnSharedVariables">
+    <Details>
+      <![CDATA[
+              <p>
+                Description of the detector....
+              </p>
+        ]]>
+    </Details>
+  </Detector>
   <!--
   **********************************************************************
   BugPatterns
@@ -8786,6 +8806,40 @@ Using floating-point variables should not be used as loop counters, as they are
       </p>]]>
     </Details>
   </BugPattern>
+  <BugPattern type="SPV_BAD_VISIBILITY_ON_SHARED_PRIMITIVE_VARIABLES">
+    <ShortDescription>Bad visibility on shared primitive variables</ShortDescription>
+    <LongDescription>Shared primitive variable "{4}" in one thread may not yield the value of the most recent write to the variable from another thread.</LongDescription>
+    <Details>
+      <![CDATA[
+        <p>
+          <a href="https://wiki.sei.cmu.edu/confluence/display/java/VNA00-J.+Ensure+visibility+when+accessing+shared+primitive+variables">SEI CERT rule VNA00-J</a>
+          describes that reading a shared primitive variable in one thread may not yield the value of the most recent write to the variable from another thread.
+          Consequently, the thread may observe a stale value of the shared variable.
+        </p>
+        <p>
+          The solution is declaring a variable volatile, changing the type to atomic or correctly synchronizing the code.
+          This guarantees that 64-bit primitive long and double variables are accessed atomically.
+        </p>
+     ]]>
+    </Details>
+  </BugPattern>
+  <BugPattern type="COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES">
+    <ShortDescription>Compound operations on shared variables</ShortDescription>
+    <LongDescription>Long desc....</LongDescription>
+    <Details>
+      <![CDATA[
+        <p>
+          <a href="https://wiki.sei.cmu.edu/confluence/display/java/VNA00-J.+Ensure+visibility+when+accessing+shared+primitive+variables">SEI CERT rule VNA00-J</a>
+          describes that reading a shared primitive variable in one thread may not yield the value of the most recent write to the variable from another thread.
+          Consequently, the thread may observe a stale value of the shared variable.
+        </p>
+        <p>
+          The solution is declaring a variable volatile, changing the type to atomic or correctly synchronizing the code.
+          This guarantees that 64-bit primitive long and double variables are accessed atomically.
+        </p>
+     ]]>
+    </Details>
+  </BugPattern>
   <!--
   **********************************************************************
    BugCodes
@@ -8939,4 +8993,6 @@ Using floating-point variables should not be used as loop counters, as they are
   <BugCode abbrev="THROWS">Exception throwing related problems</BugCode>
   <BugCode abbrev="PERM">Custom class loader does not call its superclass's getPermissions()</BugCode>
   <BugCode abbrev="USC">Potential security check based on untrusted source</BugCode>
+  <BugCode abbrev="SPV">Bad visibility on shared primitive variables</BugCode>
+  <BugCode abbrev="COSV">Compound operations on shared variables</BugCode>
 </MessageCollection>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
new file mode 100644
index 00000000000..f27eb8234e3
--- /dev/null
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
@@ -0,0 +1,158 @@
+package edu.umd.cs.findbugs.detect;
+
+import edu.umd.cs.findbugs.BugAccumulator;
+import edu.umd.cs.findbugs.BugInstance;
+import edu.umd.cs.findbugs.BugReporter;
+import edu.umd.cs.findbugs.ba.ClassContext;
+import edu.umd.cs.findbugs.ba.XField;
+import edu.umd.cs.findbugs.ba.XMethod;
+import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
+import edu.umd.cs.findbugs.util.MultiThreadedCodeIdentifierUtils;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import org.apache.bcel.Const;
+import org.apache.bcel.classfile.JavaClass;
+import org.apache.bcel.classfile.Method;
+import org.apache.bcel.classfile.Utility;
+
+public class BadVisibilityOnSharedPrimitiveVariables extends OpcodeStackDetector {
+
+    private static final Set<String> PRIMITIVE_TYPES = new HashSet<>();
+
+    static {
+        PRIMITIVE_TYPES.add("boolean");
+        PRIMITIVE_TYPES.add("byte");
+        PRIMITIVE_TYPES.add("char");
+        PRIMITIVE_TYPES.add("double");
+        PRIMITIVE_TYPES.add("float");
+        PRIMITIVE_TYPES.add("int");
+        PRIMITIVE_TYPES.add("long");
+        PRIMITIVE_TYPES.add("short");
+    }
+
+    private final BugAccumulator bugAccumulator;
+    private final Map<XMethod, List<XField>> modifiedNotSecuredFieldsByMethods;
+    private final Map<XMethod, List<XField>> comparedNotSecuredFieldsByMethods;
+    // Is this needed???
+    private boolean isInsideConstructor;
+    // Is this needed???
+    private boolean isInsideSynchronizedBlock;
+    private boolean isInsideSynchronizedOrLockingMethod;
+
+    public BadVisibilityOnSharedPrimitiveVariables(BugReporter bugReporter) {
+        this.bugAccumulator = new BugAccumulator(bugReporter);
+        this.modifiedNotSecuredFieldsByMethods = new HashMap();
+        this.comparedNotSecuredFieldsByMethods = new HashMap();
+        this.isInsideConstructor = false;
+        this.isInsideSynchronizedBlock = false;
+        this.isInsideSynchronizedOrLockingMethod = false;
+    }
+
+    @Override
+    public void visit(Method method) {
+        ClassContext currentClassContext = getClassContext();
+        isInsideSynchronizedOrLockingMethod = MultiThreadedCodeIdentifierUtils.isMethodMultiThreaded(method, currentClassContext);
+        isInsideConstructor = nameIsConstructor(method.getName());
+    }
+
+    @Override
+    public void visitAfter(JavaClass obj) {
+        bugAccumulator.reportAccumulatedBugs();
+    }
+
+    @Override
+    public void visitClassContext(ClassContext classContext) {
+        if (MultiThreadedCodeIdentifierUtils.isPartOfMultiThreadedCode(classContext)) {
+            isInsideConstructor = false;
+            isInsideSynchronizedBlock = false;
+            isInsideSynchronizedOrLockingMethod = false;
+
+            super.visitClassContext(classContext);
+        }
+    }
+
+    @Override
+    public void sawOpcode(int seen) {
+        if (seen == Const.MONITORENTER) {
+            isInsideSynchronizedBlock = true;
+            return;
+        } else if (seen == Const.MONITOREXIT) {
+            isInsideSynchronizedBlock = false;
+            return;
+        }
+
+        if (!isInsideSynchronizedBlock && !isInsideSynchronizedOrLockingMethod && !isInsideConstructor) {
+            if (seen == Const.PUTFIELD || seen == Const.PUTSTATIC) {
+                XMethod modificationMethod = getXMethod();
+                Optional<XField> maybeFieldToModify = Optional.ofNullable(getXFieldOperand());
+                if (!nameIsConstructor(modificationMethod.getName())) {
+                    lookForUnsecuredOperationsOnFieldInOtherMethods(
+                            maybeFieldToModify, modificationMethod, comparedNotSecuredFieldsByMethods, modifiedNotSecuredFieldsByMethods);
+                }
+                return;
+            }
+
+            if (seen == Const.IFGE || seen == Const.IFGT || seen == Const.IFLT || seen == Const.IFLE || seen == Const.IFNE || seen == Const.IFEQ) {
+                XMethod comparingMethod = getXMethod();
+                Optional<XField> maybeLHS = Optional.ofNullable(stack.getStackItem(0).getXField());
+                Optional<XField> maybeRHS = stack.getStackDepth() > 2
+                        ? Optional.ofNullable(stack.getStackItem(1).getXField())
+                        : Optional.empty();
+                lookForUnsecuredOperationsOnFieldInOtherMethods(
+                        maybeLHS, comparingMethod, modifiedNotSecuredFieldsByMethods, comparedNotSecuredFieldsByMethods);
+                lookForUnsecuredOperationsOnFieldInOtherMethods(
+                        maybeRHS, comparingMethod, modifiedNotSecuredFieldsByMethods, comparedNotSecuredFieldsByMethods);
+            }
+        }
+    }
+
+    private void lookForUnsecuredOperationsOnFieldInOtherMethods(
+            Optional<XField> maybeField, XMethod operatingMethod,
+            Map<XMethod, List<XField>> checkAgainstMap, Map<XMethod, List<XField>> putInMap) {
+        boolean isFieldSecured = maybeField
+                .map(field -> MultiThreadedCodeIdentifierUtils.isFieldMultiThreaded(field) || field.isFinal())
+                .orElse(true);
+        boolean isFieldPrimitive = maybeField
+                .map(field -> isPrimitive(field.getSignature()))
+                .orElse(false);
+        if (!isFieldSecured && isFieldPrimitive) {
+            XField field = maybeField.get();
+            boolean fieldGotOperatedInAnyOtherMethod = checkAgainstMap.entrySet().stream()
+                    .anyMatch(entry -> entry.getValue().contains(field) && entry.getKey() != operatingMethod);
+            if (fieldGotOperatedInAnyOtherMethod) {
+                bugAccumulator.accumulateBug(
+                        new BugInstance(this, "SPV_BAD_VISIBILITY_ON_SHARED_PRIMITIVE_VARIABLES", NORMAL_PRIORITY)
+                                .addClassAndMethod(this)
+                                .addMethod(operatingMethod)
+                                .addField(field)
+                                .addString(field.getName()),
+                        this);
+            } else {
+                boolean appendedExisting = putInMap.computeIfPresent(
+                        operatingMethod, (method, fields) -> appendToList(field, fields)) != null;
+                if (!appendedExisting) {
+                    putInMap.put(operatingMethod, new ArrayList(Collections.singletonList(field)));
+                }
+            }
+        }
+    }
+
+    private List<XField> appendToList(XField field, List<XField> list) {
+        list.add(field);
+        return list;
+    }
+
+    private boolean isPrimitive(String signature) {
+        return PRIMITIVE_TYPES.contains(Utility.signatureToString(signature));
+    }
+
+    private boolean nameIsConstructor(String name) {
+        return name.equals(Const.CONSTRUCTOR_NAME);
+    }
+}
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
new file mode 100644
index 00000000000..f016cab9138
--- /dev/null
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
@@ -0,0 +1,207 @@
+package edu.umd.cs.findbugs.detect;
+
+import edu.umd.cs.findbugs.BugAccumulator;
+import edu.umd.cs.findbugs.BugInstance;
+import edu.umd.cs.findbugs.BugReporter;
+import edu.umd.cs.findbugs.ba.ClassContext;
+import edu.umd.cs.findbugs.ba.XField;
+import edu.umd.cs.findbugs.ba.XMethod;
+import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
+import edu.umd.cs.findbugs.util.MultiThreadedCodeIdentifierUtils;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import org.apache.bcel.Const;
+import org.apache.bcel.classfile.JavaClass;
+import org.apache.bcel.classfile.Method;
+
+public class CompoundOperationsOnSharedVariables extends OpcodeStackDetector {
+
+    private final BugAccumulator bugAccumulator;
+    private final Map<XMethod, List<XField>> compoundlyWroteNotSecuredFieldsByMethods;
+    private final Map<XMethod, List<XField>> redNotSecuredFieldsByMethods;
+    // This field might not be needed at all
+    private boolean isInsideSynchronizedBlock;
+    private boolean isInsideSynchronizedOrLockingMethod;
+    private Optional<XField> maybeCompoundlyOperatedField;
+    private int stepsMadeInCompoundOperationProcess;
+
+    public CompoundOperationsOnSharedVariables(BugReporter bugReporter) {
+        this.bugAccumulator = new BugAccumulator(bugReporter);
+        this.compoundlyWroteNotSecuredFieldsByMethods = new HashMap();
+        this.redNotSecuredFieldsByMethods = new HashMap();
+        this.isInsideSynchronizedBlock = false;
+        this.isInsideSynchronizedOrLockingMethod = false;
+        this.maybeCompoundlyOperatedField = Optional.empty();
+        this.stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
+    }
+
+    @Override
+    public void visit(Method method) {
+        ClassContext currentClassContext = getClassContext();
+        isInsideSynchronizedOrLockingMethod = MultiThreadedCodeIdentifierUtils.isMethodMultiThreaded(method, currentClassContext);
+    }
+
+    @Override
+    public void visitAfter(JavaClass obj) {
+        bugAccumulator.reportAccumulatedBugs();
+    }
+
+    @Override
+    public void visitClassContext(ClassContext classContext) {
+        if (MultiThreadedCodeIdentifierUtils.isPartOfMultiThreadedCode(classContext)) {
+            isInsideSynchronizedBlock = false;
+            isInsideSynchronizedOrLockingMethod = false;
+            maybeCompoundlyOperatedField = Optional.empty();
+            stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
+
+            super.visitClassContext(classContext);
+        }
+    }
+
+    @Override
+    public void sawOpcode(int seen) {
+        if (seen == Const.MONITORENTER) {
+            isInsideSynchronizedBlock = true;
+            maybeCompoundlyOperatedField = Optional.empty();
+            stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
+            return;
+        } else if (seen == Const.MONITOREXIT) {
+            isInsideSynchronizedBlock = false;
+            maybeCompoundlyOperatedField = Optional.empty();
+            stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
+            return;
+        }
+
+        if (!isInsideSynchronizedBlock && !isInsideSynchronizedOrLockingMethod) {
+            if (seen == Const.GETFIELD || seen == Const.GETSTATIC) {
+                XMethod readMethod = getXMethod();
+                Optional<XField> maybeFieldToRead = Optional.ofNullable(getXFieldOperand());
+                lookForUnsecuredOperationsOnFieldInOtherMethods(
+                        maybeFieldToRead, readMethod, compoundlyWroteNotSecuredFieldsByMethods, redNotSecuredFieldsByMethods);
+                maybeCompoundlyOperatedField = maybeFieldToRead;
+                stepsMadeInCompoundOperationProcess = 1;
+                return;
+            }
+
+            // Possible invoke virtual first if it is a wrapper type
+            if (stepsMadeInCompoundOperationProcess == 1 && seen == Const.INVOKEVIRTUAL) {
+                return;
+            }
+
+            if (stepsMadeInCompoundOperationProcess == 1 && (isReadOpCode(seen) || isPushConstant(seen))) {
+                stepsMadeInCompoundOperationProcess = 2;
+                return;
+            }
+
+            // In case of the field's type is a wrapper type
+            if (stepsMadeInCompoundOperationProcess == 2 && seen == Const.INVOKEVIRTUAL) {
+                return;
+            }
+
+            if (stepsMadeInCompoundOperationProcess == 2 && possibleCompoundOperation(seen)) {
+                stepsMadeInCompoundOperationProcess = 3;
+                return;
+            }
+
+            // In case of wrapper types valueOf() method
+            if (stepsMadeInCompoundOperationProcess == 3 && seen == Const.INVOKESTATIC) {
+                return;
+            }
+
+            if (stepsMadeInCompoundOperationProcess == 3 && (seen == Const.PUTFIELD || seen == Const.PUTSTATIC)) {
+                // This might be a compound operation:
+                XMethod modificationMethod = getXMethod();
+                Optional<XField> maybeFieldToModify = Optional.ofNullable(getXFieldOperand());
+
+                boolean matchWithReadField = maybeCompoundlyOperatedField
+                        .map(compoundlyOperatedField -> maybeFieldToModify
+                                .map(modifiedField -> modifiedField.getName().equals(compoundlyOperatedField.getName()))
+                                .orElse(false))
+                        .orElse(false);
+                if (matchWithReadField) {
+                    lookForUnsecuredOperationsOnFieldInOtherMethods(
+                            maybeFieldToModify, modificationMethod, redNotSecuredFieldsByMethods, compoundlyWroteNotSecuredFieldsByMethods);
+
+                }
+
+                maybeCompoundlyOperatedField = Optional.empty();
+                stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
+            }
+        } else {
+            maybeCompoundlyOperatedField = Optional.empty();
+            stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
+        }
+    }
+
+    private void lookForUnsecuredOperationsOnFieldInOtherMethods(
+            Optional<XField> maybeField, XMethod operatingMethod,
+            Map<XMethod, List<XField>> checkAgainstMap, Map<XMethod, List<XField>> putInMap) {
+        boolean isFieldSecured = maybeField
+                .map(field -> MultiThreadedCodeIdentifierUtils.signatureIsFromAtomicPackage(field.getSignature())
+                        || field.isFinal())
+                .orElse(true);
+        if (!isFieldSecured) {
+            XField field = maybeField.get();
+            boolean fieldIsDangerouslyUsedByOtherMethod = checkAgainstMap.entrySet().stream()
+                    .anyMatch(entry -> entry.getValue().contains(field) && entry.getKey() != operatingMethod);
+            if (fieldIsDangerouslyUsedByOtherMethod) {
+                bugAccumulator.accumulateBug(
+                        new BugInstance(this, "COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES", NORMAL_PRIORITY)
+                                .addClassAndMethod(this)
+                                .addMethod(operatingMethod)
+                                .addField(field)
+                                .addString(field.getName()),
+                        this);
+            } else {
+                boolean appendedExisting = putInMap.computeIfPresent(
+                        operatingMethod, (method, fields) -> appendToList(field, fields)) != null;
+                if (!appendedExisting) {
+                    putInMap.put(operatingMethod, new ArrayList(Collections.singletonList(field)));
+                }
+            }
+        }
+    }
+
+    private List<XField> appendToList(XField field, List<XField> list) {
+        list.add(field);
+        return list;
+    }
+
+    private boolean isReadOpCode(int opCode) {
+        return opCode == Const.GETFIELD || opCode == Const.GETSTATIC
+                || opCode == Const.ALOAD || opCode == Const.ALOAD_0 || opCode == Const.ALOAD_1 || opCode == Const.ALOAD_2 || opCode == Const.ALOAD_3
+                || opCode == Const.DLOAD || opCode == Const.DLOAD_0 || opCode == Const.DLOAD_1 || opCode == Const.DLOAD_2 || opCode == Const.DLOAD_3
+                || opCode == Const.LLOAD || opCode == Const.LLOAD_0 || opCode == Const.LLOAD_1 || opCode == Const.LLOAD_2 || opCode == Const.LLOAD_3
+                || opCode == Const.FLOAD || opCode == Const.FLOAD_0 || opCode == Const.FLOAD_1 || opCode == Const.FLOAD_2 || opCode == Const.FLOAD_3
+                || opCode == Const.ILOAD || opCode == Const.ILOAD_0 || opCode == Const.ILOAD_1 || opCode == Const.ILOAD_2 || opCode == Const.ILOAD_3
+                || opCode == Const.DALOAD || opCode == Const.LALOAD || opCode == Const.FALOAD || opCode == Const.IALOAD;
+    }
+
+    private boolean isPushConstant(int opCode) {
+        return opCode == Const.DCONST_0 || opCode == Const.DCONST_1
+                || opCode == Const.LCONST_0 || opCode == Const.LCONST_1
+                || opCode == Const.FCONST_0 || opCode == Const.FCONST_1 || opCode == Const.FCONST_2
+                || opCode == Const.ICONST_0 || opCode == Const.ICONST_1 || opCode == Const.ICONST_2 || opCode == Const.ICONST_3 || opCode == Const.ICONST_4
+                || opCode == Const.ICONST_5
+                || opCode == Const.LDC || opCode == Const.LDC_W || opCode == Const.LDC2_W;
+    }
+
+    private boolean possibleCompoundOperation(int opCode) {
+        // +=, -=, *=, /=, %=, ++, --
+        return opCode == Const.DADD || opCode == Const.DSUB || opCode == Const.DMUL || opCode == Const.DDIV || opCode == Const.DREM
+                || opCode == Const.FADD || opCode == Const.FSUB || opCode == Const.FMUL || opCode == Const.FDIV || opCode == Const.FREM
+                || opCode == Const.LADD || opCode == Const.LSUB || opCode == Const.LMUL || opCode == Const.LDIV || opCode == Const.LREM
+                || opCode == Const.IADD || opCode == Const.ISUB || opCode == Const.IMUL || opCode == Const.IDIV || opCode == Const.IREM
+                // <<=, >>=, >>>=
+                || opCode == Const.ISHL || opCode == Const.ISHR || opCode == Const.IUSHR
+                || opCode == Const.LSHL || opCode == Const.LSHR || opCode == Const.LUSHR
+                // &=
+                || opCode == Const.IAND || opCode == Const.LAND
+                // |=, ^=
+                || opCode == Const.IOR || opCode == Const.IXOR || opCode == Const.LOR || opCode == Const.LXOR;
+    }
+}
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
new file mode 100644
index 00000000000..126e3fa31e4
--- /dev/null
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
@@ -0,0 +1,106 @@
+package edu.umd.cs.findbugs.util;
+
+import edu.umd.cs.findbugs.ba.ClassContext;
+import edu.umd.cs.findbugs.ba.XField;
+import java.util.Optional;
+import java.util.stream.Stream;
+import org.apache.bcel.classfile.Field;
+import org.apache.bcel.classfile.JavaClass;
+import org.apache.bcel.classfile.LocalVariableTable;
+import org.apache.bcel.classfile.Method;
+import org.apache.bcel.classfile.Utility;
+import org.apache.bcel.generic.ConstantPoolGen;
+import org.apache.bcel.generic.INVOKEVIRTUAL;
+import org.apache.bcel.generic.Instruction;
+import org.apache.bcel.generic.InstructionHandle;
+import org.apache.bcel.generic.MONITORENTER;
+import org.apache.bcel.generic.MethodGen;
+
+/**
+ * Utility class with methods to identify multi threaded code
+ */
+public class MultiThreadedCodeIdentifierUtils {
+
+    private static final String RUNNABLE_SIGNATURE = "java.lang.Runnable";
+    private static final String ATOMIC_PACKAGE = "java.util.concurrent.atomic";
+
+    public static boolean isPartOfMultiThreadedCode(ClassContext classContext) {
+        JavaClass classToCheck = classContext.getJavaClass();
+        if (implementsRunnable(classToCheck)) {
+            return true;
+        }
+
+        if (Stream.of(classToCheck.getFields()).anyMatch(MultiThreadedCodeIdentifierUtils::isFieldMultiThreaded)) {
+            return true;
+        }
+
+        return Stream.of(classToCheck.getMethods()).anyMatch(method -> isMethodMultiThreaded(method, classContext));
+    }
+
+    public static boolean implementsRunnable(JavaClass javaClass) {
+        try {
+            return Stream.of(javaClass.getAllInterfaces())
+                    .anyMatch(ifc -> ifc.getClassName().equals(RUNNABLE_SIGNATURE));
+        } catch (ClassNotFoundException e) {
+            return false;
+        }
+    }
+
+    public static boolean isMethodMultiThreaded(Method method, ClassContext classContext) {
+        if (method.isSynchronized()) {
+            return true;
+        }
+
+        LocalVariableTable lvt = method.getLocalVariableTable();
+        if (lvt != null && Stream.of(lvt.getLocalVariableTable())
+                .anyMatch(lv -> signatureIsFromAtomicPackage(lv.getSignature()))) {
+            return true;
+        }
+
+        Optional<MethodGen> maybeMethodGen = Optional.ofNullable(classContext.getMethodGen(method));
+        if (!maybeMethodGen.isPresent()) {
+            return false;
+        }
+
+        MethodGen methodGen = maybeMethodGen.get();
+        return hasMultiThreadedInstruction(methodGen);
+    }
+
+    public static boolean hasMultiThreadedInstruction(MethodGen methodGen) {
+        ConstantPoolGen cpg = methodGen.getConstantPool();
+        InstructionHandle handle = methodGen.getInstructionList().getStart();
+        while (handle != null) {
+            Instruction ins = handle.getInstruction();
+            if (ins instanceof MONITORENTER) {
+                return true;
+            } else if (ins instanceof INVOKEVIRTUAL) {
+                String methodName = ((INVOKEVIRTUAL) ins).getMethodName(cpg);
+                if (isConcurrentLockInterfaceCall(methodName)) {
+                    return true;
+                }
+            }
+            handle = handle.getNext();
+        }
+
+        return false;
+    }
+
+    public static boolean isConcurrentLockInterfaceCall(String methodName) {
+        return "lock".equals(methodName)
+                || "unlock".equals(methodName)
+                || "tryLock".equals(methodName)
+                || "lockInterruptibly".equals(methodName);
+    }
+
+    public static boolean isFieldMultiThreaded(Field field) {
+        return field.isVolatile() || signatureIsFromAtomicPackage(field.getSignature());
+    }
+
+    public static boolean isFieldMultiThreaded(XField field) {
+        return field.isVolatile() || signatureIsFromAtomicPackage(field.getSignature());
+    }
+
+    public static boolean signatureIsFromAtomicPackage(String signature) {
+        return Utility.signatureToString(signature).startsWith(ATOMIC_PACKAGE);
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
new file mode 100644
index 00000000000..d464987eded
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundAdditionOnSharedVolatileVariable extends Thread {
+    private volatile int num = 0;
+
+    public void toggle() {
+        num += 2;
+    }
+
+    public Integer getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
new file mode 100644
index 00000000000..4f3c3ad1651
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundDivisionOnSharedVariable extends Thread {
+    private double num = 3.0;
+
+    public void toggle() {
+        num /= 3.0;
+    }
+
+    public double getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
new file mode 100644
index 00000000000..71d8af09017
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundIANDOperationOnSharedVariable extends Thread {
+    private int num = 1;
+
+    public void toggle() {
+        num &= 3;
+    }
+
+    public double getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
new file mode 100644
index 00000000000..69f905fbdfa
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundIOROperationOnSharedVariable extends Thread {
+    private int num = 1;
+
+    public void toggle() {
+        num |= 3;
+    }
+
+    public double getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
new file mode 100644
index 00000000000..20895144e63
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
@@ -0,0 +1,17 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundLeftShiftingOnSharedVariable {
+    private int num = 1;
+
+    public void toggle() {
+        num <<= 3;
+    }
+
+    public int getNum() {
+        return num;
+    }
+
+    public synchronized void print() {
+        System.out.println("synchronized method");
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
new file mode 100644
index 00000000000..8b1c747a24f
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundLogicalRightShiftingOnSharedVariable extends Thread {
+    private int num = 1;
+
+    public void toggle() {
+        num >>>= 3;
+    }
+
+    public double getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
new file mode 100644
index 00000000000..8b8cad84360
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
@@ -0,0 +1,14 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundModuloOnSharedVariable implements Runnable {
+    private Integer num = 0;
+
+    @Override
+    public void run() {
+        num %= 2;
+    }
+
+    public Integer getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
new file mode 100644
index 00000000000..b52d3ab3c52
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundMultiplicationOnSharedVariable extends Thread {
+    private Integer num = 0;
+
+    public void toggle() {
+        num *= 2;
+    }
+
+    public Integer getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
new file mode 100644
index 00000000000..95374cdd07f
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
@@ -0,0 +1,15 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class CompoundOperationOnSharedAtomicVariable extends Thread {
+    private AtomicInteger num = new AtomicInteger(0);
+
+    public void toggle() {
+        num.set(num.get() + 2);
+    }
+
+    public Integer getNum() {
+        return num.get();
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
new file mode 100644
index 00000000000..108a0e69bd9
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundPostDecrementationOnSharedVariable extends Thread {
+    private double num = 3.0;
+
+    public void toggle() {
+        num--;
+    }
+
+    public double getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
new file mode 100644
index 00000000000..7e97adac96b
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundPostIncrementationOnSharedVariable extends Thread {
+    private double num = 3.0;
+
+    public void toggle() {
+        num++;
+    }
+
+    public double getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
new file mode 100644
index 00000000000..dd135c5e608
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundPreDecrementationOnSharedVariable extends Thread {
+    private double num = 3.0;
+
+    public void toggle() {
+        --num;
+    }
+
+    public double getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
new file mode 100644
index 00000000000..d7ec8952429
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundPreIncrementationOnSharedVariable extends Thread {
+    private double num = 3.0;
+
+    public void toggle() {
+        ++num;
+    }
+
+    public double getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
new file mode 100644
index 00000000000..c034cd55f3e
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
@@ -0,0 +1,19 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundRightShiftingOnSharedVariable {
+    private int num = 1;
+
+    public void toggle() {
+        num >>= 3;
+    }
+
+    public double getNum() {
+        return num;
+    }
+
+    public void print() {
+        synchronized(CompoundRightShiftingOnSharedVariable.class) {
+            System.out.println("synchronized block");
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
new file mode 100644
index 00000000000..28260eecc3f
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundSubtractionOnSharedVariable extends Thread {
+    private Integer num = 0;
+
+    public void toggle() {
+        num -= 2;
+    }
+
+    public Integer getNum() {
+        return num;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
new file mode 100644
index 00000000000..9428df1ecc5
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class CompoundXOROperationOnSharedVariable extends Thread {
+    private Boolean flag = true;
+
+    public void toggle(Boolean tmp) {
+        flag ^= tmp;
+    }
+
+    public boolean getFlag() {
+        return flag;
+    }
+}
\ No newline at end of file
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
new file mode 100644
index 00000000000..ef1557a6877
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
@@ -0,0 +1,15 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class SynchronizedBlockCompoundOperationOnSharedVariable extends Thread {
+    private int num = 0;
+
+    public synchronized void toggle() {
+        num += 1;
+    }
+
+    public int getFlag() {
+        synchronized (SynchronizedBlockCompoundOperationOnSharedVariable.class) {
+            return num;
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
new file mode 100644
index 00000000000..2412d345bf3
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
@@ -0,0 +1,13 @@
+package multithreaded.compoundOperationOnSharedVariables;
+
+public class SynchronizedMethodCompoundOperationOnSharedVariable extends Thread {
+    private boolean flag = true;
+
+    public synchronized void toggle() {
+        flag ^= true;
+    }
+
+    public synchronized boolean getFlag() {
+        return flag;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/AtomicField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/AtomicField.java
new file mode 100644
index 00000000000..666b479092c
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/AtomicField.java
@@ -0,0 +1,21 @@
+package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class AtomicField {
+    private AtomicBoolean done = new AtomicBoolean(false);
+
+    public void doSomething() {
+        while (!done.get()) {
+            try {
+                Thread.currentThread().sleep(1000);
+            } catch(InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    public void shutdown() {
+        done.set(true);
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
new file mode 100644
index 00000000000..3a350706e56
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
@@ -0,0 +1,20 @@
+package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+
+public class FieldWithBadVisibilityRunnable implements Runnable {
+    private boolean done = false;
+
+    @Override
+    public void run() {
+        while (!done) {
+            try {
+                Thread.currentThread().sleep(1000);
+            } catch(InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    public void shutdown() {
+        done = true;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
new file mode 100644
index 00000000000..ae3f81c2751
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
@@ -0,0 +1,20 @@
+package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+
+public class FieldWithBadVisibilityThread extends Thread {
+    private boolean done = false;
+
+    @Override
+    public void run() {
+        while (!done) {
+            try {
+                Thread.currentThread().sleep(1000);
+            } catch(InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    public void shutdown() {
+        done = true;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlock.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlock.java
new file mode 100644
index 00000000000..d398eeb1d9c
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlock.java
@@ -0,0 +1,22 @@
+package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+
+public class SynchronizedBlock implements Runnable {
+    private boolean done = false;
+
+    @Override
+    public void run() {
+        synchronized (SynchronizedBlock.class) {
+            while (!done) {
+                try {
+                    Thread.currentThread().sleep(1000);
+                } catch(InterruptedException ie) {
+                    Thread.currentThread().interrupt();
+                }
+            }
+        }
+    }
+
+    public void shutdown() {
+        done = true;
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
new file mode 100644
index 00000000000..1c52da24bf5
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
@@ -0,0 +1,25 @@
+package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+
+public class SynchronizedBlockAndBadVisibilityOnField {
+    private boolean done = false;
+
+    public void run() {
+        while (!done) {
+            try {
+                Thread.currentThread().sleep(1000);
+            } catch(InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    public void shutdown() {
+        done = true;
+    }
+
+    public void print() {
+        synchronized (SynchronizedBlockAndBadVisibilityOnField.class) {
+            System.out.println("synchronized block");
+        }
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethod.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethod.java
new file mode 100644
index 00000000000..3d1216e299d
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethod.java
@@ -0,0 +1,20 @@
+package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+
+public class SynchronizedMethod {
+    private boolean done = false;
+
+    public synchronized void doSomething() {
+        while (!done) {
+            try {
+                Thread.currentThread().sleep(1000);
+            } catch(InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    public synchronized void shutdown() {
+        done = true;
+    }
+
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
new file mode 100644
index 00000000000..13090fe6ee1
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
@@ -0,0 +1,23 @@
+package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+
+public class SynchronizedMethodAndBadVisibilityOnField {
+    private boolean done = false;
+
+    public void run() {
+        while (!done) {
+            try {
+                Thread.currentThread().sleep(1000);
+            } catch(InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    public void shutdown() {
+        done = true;
+    }
+
+    public synchronized void print() {
+        System.out.println("synchronized method");
+    }
+}
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/VolatileField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/VolatileField.java
new file mode 100644
index 00000000000..9eab3b95943
--- /dev/null
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/VolatileField.java
@@ -0,0 +1,19 @@
+package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+
+public class VolatileField {
+    private volatile boolean done = false;
+
+    public void doSomething() {
+        while (!done) {
+            try {
+                Thread.currentThread().sleep(1000);
+            } catch(InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+    }
+
+    public void shutdown() {
+        done = true;
+    }
+}

From 58743f911d13f66fc866c52b84c66cd1deb05d83 Mon Sep 17 00:00:00 2001
From: gonczmisi <gonczmisi@gmail.com>
Date: Mon, 30 May 2022 23:18:34 +0200
Subject: [PATCH 2/8] Description for COSV bug and cleanup

---
 CHANGELOG.md                                  |  3 +--
 spotbugs/etc/messages.xml                     | 19 +++++++++--------
 ...dVisibilityOnSharedPrimitiveVariables.java | 19 +----------------
 .../CompoundOperationsOnSharedVariables.java  | 21 +++----------------
 4 files changed, 15 insertions(+), 47 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c18bfe29b18..59b0a6a786a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,14 +5,13 @@ This is the changelog for SpotBugs. This follows [Keep a Changelog v1.0.0](http:
 Currently the versioning policy of this project follows [Semantic Versioning v2.0.0](http://semver.org/spec/v2.0.0.html).
 
 ## Unreleased - 2022-??-??
-
 ### Added
 * New detector `BadVisibilityOnSharedPrimitiveVariables` for new bug type `SPV_BAD_VISIBILITY_ON_SHARED_PRIMITIVE_VARIABLES` (See [SEI CERT rule VNA00-J](https://wiki.sei.cmu.edu/confluence/display/java/VNA00-J.+Ensure+visibility+when+accessing+shared+primitive+variables))
+* New detector `CompoundOperationsOnSharedVariables` for new bug type `COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES` (See [SEI CERT rule VNA02-J](https://wiki.sei.cmu.edu/confluence/display/java/VNA02-J.+Ensure+that+compound+operations+on+shared+variables+are+atomic))
 
 ### Fixed
 - Fixed False positives for `RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE` on try-with-resources with interface references ([#1931](https://github.com/spotbugs/spotbugs/issues/1931))
 
-
 ## 4.7.0 - 2022-04-14
 ### Changed
 - Updated documentation by adding parenthesis `()` to the negative odd check message ([#1995](https://github.com/spotbugs/spotbugs/issues/1995))
diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index a660f10b3f2..0dea2817e89 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -1787,7 +1787,8 @@ factory pattern to create these objects.</p>
     <Details>
       <![CDATA[
               <p>
-                Description of the detector....
+                  Detector for patterns where a shared variable inside a multithreaded class gets modified by a compound operation.
+                  Compound operations on shared variables must be performed atomically to prevent data races and race conditions.
               </p>
         ]]>
     </Details>
@@ -8824,18 +8825,18 @@ Using floating-point variables should not be used as loop counters, as they are
     </Details>
   </BugPattern>
   <BugPattern type="COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES">
-    <ShortDescription>Compound operations on shared variables</ShortDescription>
-    <LongDescription>Long desc....</LongDescription>
+    <ShortDescription>Compound operation on shared variables</ShortDescription>
+    <LongDescription>A compound operation was used on a shared variable in a multithreaded class</LongDescription>
     <Details>
       <![CDATA[
         <p>
-          <a href="https://wiki.sei.cmu.edu/confluence/display/java/VNA00-J.+Ensure+visibility+when+accessing+shared+primitive+variables">SEI CERT rule VNA00-J</a>
-          describes that reading a shared primitive variable in one thread may not yield the value of the most recent write to the variable from another thread.
-          Consequently, the thread may observe a stale value of the shared variable.
-        </p>
+          <a href="https://wiki.sei.cmu.edu/confluence/display/java/VNA02-J.+Ensure+that+compound+operations+on+shared+variables+are+atomic">SEI CERT rule VNA02-J</a>
+          describes that compound operations on shared variables must be performed atomically to prevent data races and race conditions.
+          Compound operations are operations that consist of more than one discrete operation. Expressions that include postfix or prefix increment (++), postfix or prefix decrement (--),
+          or compound assignment operators always result in compound operations.
+          Important that declaring a variable volatile fails to guarantee the atomicity of compound operations on the variable.
         <p>
-          The solution is declaring a variable volatile, changing the type to atomic or correctly synchronizing the code.
-          This guarantees that 64-bit primitive long and double variables are accessed atomically.
+          To solve this issue, synchronize compound operations, use read-write locks, or declare these shared variables with an atomic type.
         </p>
      ]]>
     </Details>
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
index f27eb8234e3..23fdea1ce43 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
@@ -39,18 +39,12 @@ public class BadVisibilityOnSharedPrimitiveVariables extends OpcodeStackDetector
     private final BugAccumulator bugAccumulator;
     private final Map<XMethod, List<XField>> modifiedNotSecuredFieldsByMethods;
     private final Map<XMethod, List<XField>> comparedNotSecuredFieldsByMethods;
-    // Is this needed???
-    private boolean isInsideConstructor;
-    // Is this needed???
-    private boolean isInsideSynchronizedBlock;
     private boolean isInsideSynchronizedOrLockingMethod;
 
     public BadVisibilityOnSharedPrimitiveVariables(BugReporter bugReporter) {
         this.bugAccumulator = new BugAccumulator(bugReporter);
         this.modifiedNotSecuredFieldsByMethods = new HashMap();
         this.comparedNotSecuredFieldsByMethods = new HashMap();
-        this.isInsideConstructor = false;
-        this.isInsideSynchronizedBlock = false;
         this.isInsideSynchronizedOrLockingMethod = false;
     }
 
@@ -58,7 +52,6 @@ public BadVisibilityOnSharedPrimitiveVariables(BugReporter bugReporter) {
     public void visit(Method method) {
         ClassContext currentClassContext = getClassContext();
         isInsideSynchronizedOrLockingMethod = MultiThreadedCodeIdentifierUtils.isMethodMultiThreaded(method, currentClassContext);
-        isInsideConstructor = nameIsConstructor(method.getName());
     }
 
     @Override
@@ -69,8 +62,6 @@ public void visitAfter(JavaClass obj) {
     @Override
     public void visitClassContext(ClassContext classContext) {
         if (MultiThreadedCodeIdentifierUtils.isPartOfMultiThreadedCode(classContext)) {
-            isInsideConstructor = false;
-            isInsideSynchronizedBlock = false;
             isInsideSynchronizedOrLockingMethod = false;
 
             super.visitClassContext(classContext);
@@ -79,15 +70,7 @@ public void visitClassContext(ClassContext classContext) {
 
     @Override
     public void sawOpcode(int seen) {
-        if (seen == Const.MONITORENTER) {
-            isInsideSynchronizedBlock = true;
-            return;
-        } else if (seen == Const.MONITOREXIT) {
-            isInsideSynchronizedBlock = false;
-            return;
-        }
-
-        if (!isInsideSynchronizedBlock && !isInsideSynchronizedOrLockingMethod && !isInsideConstructor) {
+        if (!isInsideSynchronizedOrLockingMethod) {
             if (seen == Const.PUTFIELD || seen == Const.PUTSTATIC) {
                 XMethod modificationMethod = getXMethod();
                 Optional<XField> maybeFieldToModify = Optional.ofNullable(getXFieldOperand());
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
index f016cab9138..3eaf1985ffc 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
@@ -23,8 +23,6 @@ public class CompoundOperationsOnSharedVariables extends OpcodeStackDetector {
     private final BugAccumulator bugAccumulator;
     private final Map<XMethod, List<XField>> compoundlyWroteNotSecuredFieldsByMethods;
     private final Map<XMethod, List<XField>> redNotSecuredFieldsByMethods;
-    // This field might not be needed at all
-    private boolean isInsideSynchronizedBlock;
     private boolean isInsideSynchronizedOrLockingMethod;
     private Optional<XField> maybeCompoundlyOperatedField;
     private int stepsMadeInCompoundOperationProcess;
@@ -33,7 +31,6 @@ public CompoundOperationsOnSharedVariables(BugReporter bugReporter) {
         this.bugAccumulator = new BugAccumulator(bugReporter);
         this.compoundlyWroteNotSecuredFieldsByMethods = new HashMap();
         this.redNotSecuredFieldsByMethods = new HashMap();
-        this.isInsideSynchronizedBlock = false;
         this.isInsideSynchronizedOrLockingMethod = false;
         this.maybeCompoundlyOperatedField = Optional.empty();
         this.stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
@@ -53,7 +50,6 @@ public void visitAfter(JavaClass obj) {
     @Override
     public void visitClassContext(ClassContext classContext) {
         if (MultiThreadedCodeIdentifierUtils.isPartOfMultiThreadedCode(classContext)) {
-            isInsideSynchronizedBlock = false;
             isInsideSynchronizedOrLockingMethod = false;
             maybeCompoundlyOperatedField = Optional.empty();
             stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
@@ -64,19 +60,7 @@ public void visitClassContext(ClassContext classContext) {
 
     @Override
     public void sawOpcode(int seen) {
-        if (seen == Const.MONITORENTER) {
-            isInsideSynchronizedBlock = true;
-            maybeCompoundlyOperatedField = Optional.empty();
-            stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
-            return;
-        } else if (seen == Const.MONITOREXIT) {
-            isInsideSynchronizedBlock = false;
-            maybeCompoundlyOperatedField = Optional.empty();
-            stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
-            return;
-        }
-
-        if (!isInsideSynchronizedBlock && !isInsideSynchronizedOrLockingMethod) {
+        if (!isInsideSynchronizedOrLockingMethod) {
             if (seen == Const.GETFIELD || seen == Const.GETSTATIC) {
                 XMethod readMethod = getXMethod();
                 Optional<XField> maybeFieldToRead = Optional.ofNullable(getXFieldOperand());
@@ -185,7 +169,8 @@ private boolean isPushConstant(int opCode) {
         return opCode == Const.DCONST_0 || opCode == Const.DCONST_1
                 || opCode == Const.LCONST_0 || opCode == Const.LCONST_1
                 || opCode == Const.FCONST_0 || opCode == Const.FCONST_1 || opCode == Const.FCONST_2
-                || opCode == Const.ICONST_0 || opCode == Const.ICONST_1 || opCode == Const.ICONST_2 || opCode == Const.ICONST_3 || opCode == Const.ICONST_4
+                || opCode == Const.ICONST_0 || opCode == Const.ICONST_1 || opCode == Const.ICONST_2 || opCode == Const.ICONST_3
+                || opCode == Const.ICONST_4
                 || opCode == Const.ICONST_5
                 || opCode == Const.LDC || opCode == Const.LDC_W || opCode == Const.LDC2_W;
     }

From 7be029f10ccd2e457dbfee3443df121abe162a22 Mon Sep 17 00:00:00 2001
From: gonczmisi <gonczmisi@gmail.com>
Date: Mon, 30 May 2022 23:27:36 +0200
Subject: [PATCH 3/8] Fixed packaging error

---
 .../BadVisibilityOnSharedPrimitiveVariablesTest.java      | 8 ++++----
 .../{sharedPrimitiveVariables => }/AtomicField.java       | 2 +-
 .../FieldWithBadVisibilityRunnable.java                   | 2 +-
 .../FieldWithBadVisibilityThread.java                     | 2 +-
 .../{sharedPrimitiveVariables => }/SynchronizedBlock.java | 2 +-
 .../SynchronizedBlockAndBadVisibilityOnField.java         | 2 +-
 .../SynchronizedMethod.java                               | 2 +-
 .../SynchronizedMethodAndBadVisibilityOnField.java        | 2 +-
 .../{sharedPrimitiveVariables => }/VolatileField.java     | 2 +-
 9 files changed, 12 insertions(+), 12 deletions(-)
 rename spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/{sharedPrimitiveVariables => }/AtomicField.java (86%)
 rename spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/{sharedPrimitiveVariables => }/FieldWithBadVisibilityRunnable.java (85%)
 rename spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/{sharedPrimitiveVariables => }/FieldWithBadVisibilityThread.java (85%)
 rename spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/{sharedPrimitiveVariables => }/SynchronizedBlock.java (87%)
 rename spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/{sharedPrimitiveVariables => }/SynchronizedBlockAndBadVisibilityOnField.java (88%)
 rename spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/{sharedPrimitiveVariables => }/SynchronizedMethod.java (84%)
 rename spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/{sharedPrimitiveVariables => }/SynchronizedMethodAndBadVisibilityOnField.java (87%)
 rename spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/{sharedPrimitiveVariables => }/VolatileField.java (84%)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
index 1e98288d5a6..92d9ddb62f7 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
@@ -18,7 +18,7 @@ public void failurePath_fieldWithBadVisibility_whenOtherMethodHasSynchronizedBlo
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.class");
 
         assertSPVNumOfBugs(1);
-        assertSPVBug("SynchronizedBlockAndBadVisibilityOnField", "shutdown", 18);
+        assertSPVBug("SynchronizedBlockAndBadVisibilityOnField", "shutdown", 17);
     }
 
     @Test
@@ -27,7 +27,7 @@ public void failurePath_fieldWithBadVisibility_whenOtherMethodIsSynchronized() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.class");
 
         assertSPVNumOfBugs(1);
-        assertSPVBug("SynchronizedMethodAndBadVisibilityOnField", "shutdown", 18);
+        assertSPVBug("SynchronizedMethodAndBadVisibilityOnField", "shutdown", 17);
     }
 
     @Test
@@ -36,7 +36,7 @@ public void failurePath_fieldWithBadVisibility_whenClassExtendsThread() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.class");
 
         assertSPVNumOfBugs(1);
-        assertSPVBug("FieldWithBadVisibilityThread", "shutdown", 19);
+        assertSPVBug("FieldWithBadVisibilityThread", "shutdown", 18);
     }
 
     @Test
@@ -45,7 +45,7 @@ public void failurePath_fieldWithBadVisibility_whenClassImplementsRunnable() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.class");
 
         assertSPVNumOfBugs(1);
-        assertSPVBug("FieldWithBadVisibilityRunnable", "shutdown", 19);
+        assertSPVBug("FieldWithBadVisibilityRunnable", "shutdown", 18);
     }
 
     @Test
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/AtomicField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
similarity index 86%
rename from spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/AtomicField.java
rename to spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
index 666b479092c..3b3f8f03481 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/AtomicField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
@@ -1,4 +1,4 @@
-package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+package multithreaded.sharedPrimitiveVariables;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
similarity index 85%
rename from spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
rename to spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
index 3a350706e56..e8dee9dd0a5 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
@@ -1,4 +1,4 @@
-package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+package multithreaded.sharedPrimitiveVariables;
 
 public class FieldWithBadVisibilityRunnable implements Runnable {
     private boolean done = false;
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
similarity index 85%
rename from spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
rename to spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
index ae3f81c2751..40d5c447a5b 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
@@ -1,4 +1,4 @@
-package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+package multithreaded.sharedPrimitiveVariables;
 
 public class FieldWithBadVisibilityThread extends Thread {
     private boolean done = false;
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlock.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
similarity index 87%
rename from spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlock.java
rename to spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
index d398eeb1d9c..547662a2b68 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlock.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
@@ -1,4 +1,4 @@
-package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedBlock implements Runnable {
     private boolean done = false;
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
similarity index 88%
rename from spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
rename to spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
index 1c52da24bf5..220a122dbcb 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
@@ -1,4 +1,4 @@
-package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedBlockAndBadVisibilityOnField {
     private boolean done = false;
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethod.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
similarity index 84%
rename from spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethod.java
rename to spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
index 3d1216e299d..d7a626c0543 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethod.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
@@ -1,4 +1,4 @@
-package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedMethod {
     private boolean done = false;
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
similarity index 87%
rename from spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
rename to spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
index 13090fe6ee1..d710ebede25 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
@@ -1,4 +1,4 @@
-package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedMethodAndBadVisibilityOnField {
     private boolean done = false;
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/VolatileField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
similarity index 84%
rename from spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/VolatileField.java
rename to spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
index 9eab3b95943..ad735840553 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/sharedPrimitiveVariables/VolatileField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
@@ -1,4 +1,4 @@
-package multithreaded.sharedPrimitiveVariables.sharedPrimitiveVariables;
+package multithreaded.sharedPrimitiveVariables;
 
 public class VolatileField {
     private volatile boolean done = false;

From c6900e1b9ccb3a162eb503b0e3b4ad91ee1936bf Mon Sep 17 00:00:00 2001
From: gonczmisi <gonczmisi@gmail.com>
Date: Mon, 13 Jun 2022 23:11:27 +0200
Subject: [PATCH 4/8] PR review fixes: pre-test ful debug logging command,
 fixed typos, added lincense headers

---
 ...ibilityOnSharedPrimitiveVariablesTest.java | 41 +++++++-----
 ...mpoundOperationsOnSharedVariablesTest.java | 64 ++++++++-----------
 ...dVisibilityOnSharedPrimitiveVariables.java | 19 ++++++
 .../CompoundOperationsOnSharedVariables.java  | 32 ++++++++--
 .../MultiThreadedCodeIdentifierUtils.java     | 19 ++++++
 ...poundAdditionOnSharedVolatileVariable.java | 19 ++++++
 .../CompoundDivisionOnSharedVariable.java     | 19 ++++++
 ...CompoundIANDOperationOnSharedVariable.java | 19 ++++++
 .../CompoundIOROperationOnSharedVariable.java | 19 ++++++
 .../CompoundLeftShiftingOnSharedVariable.java | 19 ++++++
 ...dLogicalRightShiftingOnSharedVariable.java | 19 ++++++
 .../CompoundModuloOnSharedVariable.java       | 19 ++++++
 ...ompoundMultiplicationOnSharedVariable.java | 19 ++++++
 ...mpoundOperationOnSharedAtomicVariable.java | 19 ++++++
 ...undPostDecrementationOnSharedVariable.java | 19 ++++++
 ...undPostIncrementationOnSharedVariable.java | 19 ++++++
 ...oundPreDecrementationOnSharedVariable.java | 19 ++++++
 ...oundPreIncrementationOnSharedVariable.java | 19 ++++++
 ...CompoundRightShiftingOnSharedVariable.java | 19 ++++++
 .../CompoundSubtractionOnSharedVariable.java  | 19 ++++++
 .../CompoundXOROperationOnSharedVariable.java | 19 ++++++
 ...lockCompoundOperationOnSharedVariable.java | 19 ++++++
 ...thodCompoundOperationOnSharedVariable.java | 19 ++++++
 .../sharedPrimitiveVariables/AtomicField.java | 19 ++++++
 .../FieldWithBadVisibilityRunnable.java       | 19 ++++++
 .../FieldWithBadVisibilityThread.java         | 19 ++++++
 .../SynchronizedBlock.java                    | 19 ++++++
 ...chronizedBlockAndBadVisibilityOnField.java | 19 ++++++
 .../SynchronizedMethod.java                   | 19 ++++++
 ...hronizedMethodAndBadVisibilityOnField.java | 19 ++++++
 .../VolatileField.java                        | 19 ++++++
 31 files changed, 608 insertions(+), 61 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
index 92d9ddb62f7..b88ae57b969 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
@@ -1,9 +1,29 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.AbstractIntegrationTest;
 import edu.umd.cs.findbugs.SystemProperties;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+import org.junit.Before;
 import org.junit.Test;
 
 import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
@@ -12,71 +32,60 @@
 
 public class BadVisibilityOnSharedPrimitiveVariablesTest extends AbstractIntegrationTest {
 
+    @Before
+    public void setup() {
+        SystemProperties.setProperty("ful.debug", "true");
+    }
+
     @Test
     public void failurePath_fieldWithBadVisibility_whenOtherMethodHasSynchronizedBlock() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.class");
-
         assertSPVNumOfBugs(1);
         assertSPVBug("SynchronizedBlockAndBadVisibilityOnField", "shutdown", 17);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenOtherMethodIsSynchronized() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.class");
-
         assertSPVNumOfBugs(1);
         assertSPVBug("SynchronizedMethodAndBadVisibilityOnField", "shutdown", 17);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenClassExtendsThread() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.class");
-
         assertSPVNumOfBugs(1);
         assertSPVBug("FieldWithBadVisibilityThread", "shutdown", 18);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenClassImplementsRunnable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.class");
-
         assertSPVNumOfBugs(1);
         assertSPVBug("FieldWithBadVisibilityRunnable", "shutdown", 18);
     }
 
     @Test
     public void happyPath_atomicField() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/sharedPrimitiveVariables/AtomicField.class");
-
         assertSPVNumOfBugs(0);
     }
 
     @Test
     public void happyPath_volatileField() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/sharedPrimitiveVariables/VolatileField.class");
-
         assertSPVNumOfBugs(0);
     }
 
     @Test
     public void happyPath_synchronizedBlock() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedBlock.class");
-
         assertSPVNumOfBugs(0);
     }
 
     @Test
     public void happyPath_synchronizedMethod() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedMethod.class");
-
         assertSPVNumOfBugs(0);
     }
 
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
index a3b7d8d5b74..4eb1c37aacd 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
@@ -1,48 +1,64 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.AbstractIntegrationTest;
 import edu.umd.cs.findbugs.SystemProperties;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcher;
 import edu.umd.cs.findbugs.test.matcher.BugInstanceMatcherBuilder;
+import org.junit.Before;
 import org.junit.Test;
 
 import static edu.umd.cs.findbugs.test.CountMatcher.containsExactly;
-import static org.hamcrest.Matchers.hasItem;
-
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasItem;
 
 public class FindCompoundOperationsOnSharedVariablesTest extends AbstractIntegrationTest {
 
+    @Before
+    public void setup() {
+        SystemProperties.setProperty("ful.debug", "true");
+    }
+
     @Test
     public void happyPath_compoundOperation_onSharedAtomicVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.class");
-
         assertCOSVNumOfBugs(0);
     }
 
     @Test
     public void happyPath_compoundOperationInsideSynchronizedBlock_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(0);
     }
 
     @Test
     public void happyPath_compoundOperationInsideSynchronizedMethod_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(0);
     }
 
     // --num
     @Test
     public void reportsBugFor_compoundPreDecrementation_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundPreDecrementationOnSharedVariable", "getNum", 11);
     }
@@ -50,9 +66,7 @@ public void reportsBugFor_compoundPreDecrementation_onSharedVariable() {
     // num--
     @Test
     public void reportsBugFor_compoundPostDecrementation_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundPostDecrementationOnSharedVariable", "getNum", 11);
     }
@@ -60,9 +74,7 @@ public void reportsBugFor_compoundPostDecrementation_onSharedVariable() {
     // ++num
     @Test
     public void reportsBugFor_compoundPreIncrementation_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundPreIncrementationOnSharedVariable", "getNum", 11);
     }
@@ -70,9 +82,7 @@ public void reportsBugFor_compoundPreIncrementation_onSharedVariable() {
     // num++
     @Test
     public void reportsBugFor_compoundPostIncrementation_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundPostIncrementationOnSharedVariable", "getNum", 11);
     }
@@ -80,9 +90,7 @@ public void reportsBugFor_compoundPostIncrementation_onSharedVariable() {
     // &=
     @Test
     public void reportsBugFor_compoundIAND_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundIANDOperationOnSharedVariable", "getNum", 11);
     }
@@ -90,9 +98,7 @@ public void reportsBugFor_compoundIAND_onSharedVariable() {
     // |=
     @Test
     public void reportsBugFor_compoundIOR_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundIOROperationOnSharedVariable", "getNum", 11);
     }
@@ -100,9 +106,7 @@ public void reportsBugFor_compoundIOR_onSharedVariable() {
     // >>>=
     @Test
     public void reportsBugFor_compoundLogicalRightShifting_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundLogicalRightShiftingOnSharedVariable", "getNum", 11);
     }
@@ -110,9 +114,7 @@ public void reportsBugFor_compoundLogicalRightShifting_onSharedVariable() {
     // >>=
     @Test
     public void reportsBugFor_compoundRightShifting_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundRightShiftingOnSharedVariable", "getNum", 11);
     }
@@ -120,9 +122,7 @@ public void reportsBugFor_compoundRightShifting_onSharedVariable() {
     // <<=
     @Test
     public void reportsBugFor_compoundLeftShifting_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundLeftShiftingOnSharedVariable", "getNum", 11);
     }
@@ -130,9 +130,7 @@ public void reportsBugFor_compoundLeftShifting_onSharedVariable() {
     // %=
     @Test
     public void reportsBugFor_compoundModulo_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundModuloOnSharedVariable", "getNum", 12);
     }
@@ -140,9 +138,7 @@ public void reportsBugFor_compoundModulo_onSharedVariable() {
     // *=
     @Test
     public void reportsBugFor_compoundMultiplication_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundMultiplicationOnSharedVariable", "getNum", 11);
     }
@@ -150,9 +146,7 @@ public void reportsBugFor_compoundMultiplication_onSharedVariable() {
     // /=
     @Test
     public void reportsBugFor_compoundDivision_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundDivisionOnSharedVariable", "getNum", 11);
     }
@@ -160,9 +154,7 @@ public void reportsBugFor_compoundDivision_onSharedVariable() {
     // -=
     @Test
     public void reportsBugFor_compoundSubtraction_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundSubtractionOnSharedVariable", "getNum", 11);
     }
@@ -171,9 +163,7 @@ public void reportsBugFor_compoundSubtraction_onSharedVariable() {
     // +=
     @Test
     public void reportsBugFor_compoundAddition_onSharedVolatileVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundAdditionOnSharedVolatileVariable", "getNum", 11);
     }
@@ -181,9 +171,7 @@ public void reportsBugFor_compoundAddition_onSharedVolatileVariable() {
     // ^=
     @Test
     public void reportsBugFor_compoundXOROperation_onSharedVariable() {
-        SystemProperties.setProperty("ful.debug", "true");
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.class");
-
         assertCOSVNumOfBugs(1);
         assertCOSVBug("CompoundXOROperationOnSharedVariable", "getFlag", 11);
     }
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
index 23fdea1ce43..c3b4b078c80 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.BugAccumulator;
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
index 3eaf1985ffc..255d624242a 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find bugs in Java programs
+ * Copyright (C) 2003,2004 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package edu.umd.cs.findbugs.detect;
 
 import edu.umd.cs.findbugs.BugAccumulator;
@@ -21,16 +40,16 @@
 public class CompoundOperationsOnSharedVariables extends OpcodeStackDetector {
 
     private final BugAccumulator bugAccumulator;
-    private final Map<XMethod, List<XField>> compoundlyWroteNotSecuredFieldsByMethods;
-    private final Map<XMethod, List<XField>> redNotSecuredFieldsByMethods;
+    private final Map<XMethod, List<XField>> compoundlyWrittenNotSecuredFieldsByMethods;
+    private final Map<XMethod, List<XField>> readNotSecuredFieldsByMethods;
     private boolean isInsideSynchronizedOrLockingMethod;
     private Optional<XField> maybeCompoundlyOperatedField;
     private int stepsMadeInCompoundOperationProcess;
 
     public CompoundOperationsOnSharedVariables(BugReporter bugReporter) {
         this.bugAccumulator = new BugAccumulator(bugReporter);
-        this.compoundlyWroteNotSecuredFieldsByMethods = new HashMap();
-        this.redNotSecuredFieldsByMethods = new HashMap();
+        this.compoundlyWrittenNotSecuredFieldsByMethods = new HashMap();
+        this.readNotSecuredFieldsByMethods = new HashMap();
         this.isInsideSynchronizedOrLockingMethod = false;
         this.maybeCompoundlyOperatedField = Optional.empty();
         this.stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
@@ -65,7 +84,7 @@ public void sawOpcode(int seen) {
                 XMethod readMethod = getXMethod();
                 Optional<XField> maybeFieldToRead = Optional.ofNullable(getXFieldOperand());
                 lookForUnsecuredOperationsOnFieldInOtherMethods(
-                        maybeFieldToRead, readMethod, compoundlyWroteNotSecuredFieldsByMethods, redNotSecuredFieldsByMethods);
+                        maybeFieldToRead, readMethod, compoundlyWrittenNotSecuredFieldsByMethods, readNotSecuredFieldsByMethods);
                 maybeCompoundlyOperatedField = maybeFieldToRead;
                 stepsMadeInCompoundOperationProcess = 1;
                 return;
@@ -97,7 +116,6 @@ public void sawOpcode(int seen) {
             }
 
             if (stepsMadeInCompoundOperationProcess == 3 && (seen == Const.PUTFIELD || seen == Const.PUTSTATIC)) {
-                // This might be a compound operation:
                 XMethod modificationMethod = getXMethod();
                 Optional<XField> maybeFieldToModify = Optional.ofNullable(getXFieldOperand());
 
@@ -108,7 +126,7 @@ public void sawOpcode(int seen) {
                         .orElse(false);
                 if (matchWithReadField) {
                     lookForUnsecuredOperationsOnFieldInOtherMethods(
-                            maybeFieldToModify, modificationMethod, redNotSecuredFieldsByMethods, compoundlyWroteNotSecuredFieldsByMethods);
+                            maybeFieldToModify, modificationMethod, readNotSecuredFieldsByMethods, compoundlyWrittenNotSecuredFieldsByMethods);
 
                 }
 
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
index 126e3fa31e4..270816e6421 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find bugs in Java programs
+ * Copyright (C) 2003,2004 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package edu.umd.cs.findbugs.util;
 
 import edu.umd.cs.findbugs.ba.ClassContext;
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
index d464987eded..5d6a493f389 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundAdditionOnSharedVolatileVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
index 4f3c3ad1651..bd79d52e0ea 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundDivisionOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
index 71d8af09017..0f685a85dcd 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundIANDOperationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
index 69f905fbdfa..04e34ef7369 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundIOROperationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
index 20895144e63..4b80bfd2501 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundLeftShiftingOnSharedVariable {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
index 8b1c747a24f..858b98d1441 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundLogicalRightShiftingOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
index 8b8cad84360..d06c12397a4 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundModuloOnSharedVariable implements Runnable {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
index b52d3ab3c52..a18a0c8b2bb 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundMultiplicationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
index 95374cdd07f..4e38b13120d 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 import java.util.concurrent.atomic.AtomicInteger;
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
index 108a0e69bd9..edf4fc704c4 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundPostDecrementationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
index 7e97adac96b..d7c2637d6bb 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundPostIncrementationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
index dd135c5e608..1c353f5ddfc 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundPreDecrementationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
index d7ec8952429..a4b09c1f82b 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundPreIncrementationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
index c034cd55f3e..2d42ed9e50e 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundRightShiftingOnSharedVariable {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
index 28260eecc3f..eacfb94c36c 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundSubtractionOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
index 9428df1ecc5..1c63dccf4d4 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class CompoundXOROperationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
index ef1557a6877..5a3c8692749 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class SynchronizedBlockCompoundOperationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
index 2412d345bf3..a9cb881d2ba 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.compoundOperationOnSharedVariables;
 
 public class SynchronizedMethodCompoundOperationOnSharedVariable extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
index 3b3f8f03481..66f3165c88b 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.sharedPrimitiveVariables;
 
 import java.util.concurrent.atomic.AtomicBoolean;
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
index e8dee9dd0a5..7c851ad3ffd 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.sharedPrimitiveVariables;
 
 public class FieldWithBadVisibilityRunnable implements Runnable {
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
index 40d5c447a5b..88715d9289c 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.sharedPrimitiveVariables;
 
 public class FieldWithBadVisibilityThread extends Thread {
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
index 547662a2b68..ef6cbd09f65 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedBlock implements Runnable {
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
index 220a122dbcb..0b634919681 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedBlockAndBadVisibilityOnField {
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
index d7a626c0543..48fce78e0d6 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedMethod {
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
index d710ebede25..90d7744582a 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedMethodAndBadVisibilityOnField {
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
index ad735840553..3ee53b574d6 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
@@ -1,3 +1,22 @@
+/*
+ * FindBugs - Find Bugs in Java programs
+ * Copyright (C) 2003-2008 University of Maryland
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
 package multithreaded.sharedPrimitiveVariables;
 
 public class VolatileField {

From eea20b0f0a7a12c61180355ba7f3a6c735380556 Mon Sep 17 00:00:00 2001
From: gonczmisi <gonczmisi@gmail.com>
Date: Mon, 13 Jun 2022 23:34:44 +0200
Subject: [PATCH 5/8] Aligned line numbers for tests with linceses

---
 ...ibilityOnSharedPrimitiveVariablesTest.java |  8 ++---
 ...mpoundOperationsOnSharedVariablesTest.java | 30 +++++++++----------
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
index b88ae57b969..a0fe7a7a8f1 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
@@ -41,28 +41,28 @@ public void setup() {
     public void failurePath_fieldWithBadVisibility_whenOtherMethodHasSynchronizedBlock() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.class");
         assertSPVNumOfBugs(1);
-        assertSPVBug("SynchronizedBlockAndBadVisibilityOnField", "shutdown", 17);
+        assertSPVBug("SynchronizedBlockAndBadVisibilityOnField", "shutdown", 36);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenOtherMethodIsSynchronized() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.class");
         assertSPVNumOfBugs(1);
-        assertSPVBug("SynchronizedMethodAndBadVisibilityOnField", "shutdown", 17);
+        assertSPVBug("SynchronizedMethodAndBadVisibilityOnField", "shutdown", 36);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenClassExtendsThread() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.class");
         assertSPVNumOfBugs(1);
-        assertSPVBug("FieldWithBadVisibilityThread", "shutdown", 18);
+        assertSPVBug("FieldWithBadVisibilityThread", "shutdown", 37);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenClassImplementsRunnable() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.class");
         assertSPVNumOfBugs(1);
-        assertSPVBug("FieldWithBadVisibilityRunnable", "shutdown", 18);
+        assertSPVBug("FieldWithBadVisibilityRunnable", "shutdown", 37);
     }
 
     @Test
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
index 4eb1c37aacd..09c7cd95268 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
@@ -60,7 +60,7 @@ public void happyPath_compoundOperationInsideSynchronizedMethod_onSharedVariable
     public void reportsBugFor_compoundPreDecrementation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundPreDecrementationOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundPreDecrementationOnSharedVariable", "getNum", 30);
     }
 
     // num--
@@ -68,7 +68,7 @@ public void reportsBugFor_compoundPreDecrementation_onSharedVariable() {
     public void reportsBugFor_compoundPostDecrementation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundPostDecrementationOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundPostDecrementationOnSharedVariable", "getNum", 30);
     }
 
     // ++num
@@ -76,7 +76,7 @@ public void reportsBugFor_compoundPostDecrementation_onSharedVariable() {
     public void reportsBugFor_compoundPreIncrementation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundPreIncrementationOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundPreIncrementationOnSharedVariable", "getNum", 30);
     }
 
     // num++
@@ -84,7 +84,7 @@ public void reportsBugFor_compoundPreIncrementation_onSharedVariable() {
     public void reportsBugFor_compoundPostIncrementation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundPostIncrementationOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundPostIncrementationOnSharedVariable", "getNum", 30);
     }
 
     // &=
@@ -92,7 +92,7 @@ public void reportsBugFor_compoundPostIncrementation_onSharedVariable() {
     public void reportsBugFor_compoundIAND_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundIANDOperationOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundIANDOperationOnSharedVariable", "getNum", 30);
     }
 
     // |=
@@ -100,7 +100,7 @@ public void reportsBugFor_compoundIAND_onSharedVariable() {
     public void reportsBugFor_compoundIOR_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundIOROperationOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundIOROperationOnSharedVariable", "getNum", 30);
     }
 
     // >>>=
@@ -108,7 +108,7 @@ public void reportsBugFor_compoundIOR_onSharedVariable() {
     public void reportsBugFor_compoundLogicalRightShifting_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundLogicalRightShiftingOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundLogicalRightShiftingOnSharedVariable", "getNum", 30);
     }
 
     // >>=
@@ -116,7 +116,7 @@ public void reportsBugFor_compoundLogicalRightShifting_onSharedVariable() {
     public void reportsBugFor_compoundRightShifting_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundRightShiftingOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundRightShiftingOnSharedVariable", "getNum", 30);
     }
 
     // <<=
@@ -124,7 +124,7 @@ public void reportsBugFor_compoundRightShifting_onSharedVariable() {
     public void reportsBugFor_compoundLeftShifting_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundLeftShiftingOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundLeftShiftingOnSharedVariable", "getNum", 30);
     }
 
     // %=
@@ -132,7 +132,7 @@ public void reportsBugFor_compoundLeftShifting_onSharedVariable() {
     public void reportsBugFor_compoundModulo_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundModuloOnSharedVariable", "getNum", 12);
+        assertCOSVBug("CompoundModuloOnSharedVariable", "getNum", 31);
     }
 
     // *=
@@ -140,7 +140,7 @@ public void reportsBugFor_compoundModulo_onSharedVariable() {
     public void reportsBugFor_compoundMultiplication_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundMultiplicationOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundMultiplicationOnSharedVariable", "getNum", 30);
     }
 
     // /=
@@ -148,7 +148,7 @@ public void reportsBugFor_compoundMultiplication_onSharedVariable() {
     public void reportsBugFor_compoundDivision_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundDivisionOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundDivisionOnSharedVariable", "getNum", 30);
     }
 
     // -=
@@ -156,7 +156,7 @@ public void reportsBugFor_compoundDivision_onSharedVariable() {
     public void reportsBugFor_compoundSubtraction_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundSubtractionOnSharedVariable", "getNum", 11);
+        assertCOSVBug("CompoundSubtractionOnSharedVariable", "getNum", 30);
     }
 
 
@@ -165,7 +165,7 @@ public void reportsBugFor_compoundSubtraction_onSharedVariable() {
     public void reportsBugFor_compoundAddition_onSharedVolatileVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundAdditionOnSharedVolatileVariable", "getNum", 11);
+        assertCOSVBug("CompoundAdditionOnSharedVolatileVariable", "getNum", 30);
     }
 
     // ^=
@@ -173,7 +173,7 @@ public void reportsBugFor_compoundAddition_onSharedVolatileVariable() {
     public void reportsBugFor_compoundXOROperation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundXOROperationOnSharedVariable", "getFlag", 11);
+        assertCOSVBug("CompoundXOROperationOnSharedVariable", "getFlag", 30);
     }
 
     private void assertCOSVNumOfBugs(int num) {

From 5c9ce1b4596cee145926acec14072c589720bbbf Mon Sep 17 00:00:00 2001
From: gonczmisi <gonczmisi@gmail.com>
Date: Fri, 24 Jun 2022 15:53:38 +0200
Subject: [PATCH 6/8] PR review fixes v2

---
 ...ibilityOnSharedPrimitiveVariablesTest.java | 11 ++--
 ...mpoundOperationsOnSharedVariablesTest.java | 33 +++++-----
 ...dVisibilityOnSharedPrimitiveVariables.java |  3 +-
 .../CompoundOperationsOnSharedVariables.java  | 61 ++++++++++---------
 .../MultiThreadedCodeIdentifierUtils.java     | 10 +--
 ...poundAdditionOnSharedVolatileVariable.java |  3 +-
 .../CompoundDivisionOnSharedVariable.java     |  3 +-
 ...CompoundIANDOperationOnSharedVariable.java |  3 +-
 .../CompoundIOROperationOnSharedVariable.java |  3 +-
 .../CompoundLeftShiftingOnSharedVariable.java |  3 +-
 ...dLogicalRightShiftingOnSharedVariable.java |  3 +-
 .../CompoundModuloOnSharedVariable.java       |  3 +-
 ...ompoundMultiplicationOnSharedVariable.java |  3 +-
 ...mpoundOperationOnSharedAtomicVariable.java |  3 +-
 ...undPostDecrementationOnSharedVariable.java |  3 +-
 ...undPostIncrementationOnSharedVariable.java |  3 +-
 ...oundPreDecrementationOnSharedVariable.java |  3 +-
 ...oundPreIncrementationOnSharedVariable.java |  3 +-
 ...CompoundRightShiftingOnSharedVariable.java |  3 +-
 .../CompoundSubtractionOnSharedVariable.java  |  3 +-
 .../CompoundXOROperationOnSharedVariable.java |  3 +-
 ...lockCompoundOperationOnSharedVariable.java |  3 +-
 ...thodCompoundOperationOnSharedVariable.java |  3 +-
 .../sharedPrimitiveVariables/AtomicField.java |  3 +-
 .../FieldWithBadVisibilityRunnable.java       |  3 +-
 .../FieldWithBadVisibilityThread.java         |  3 +-
 .../SynchronizedBlock.java                    |  4 +-
 ...chronizedBlockAndBadVisibilityOnField.java |  3 +-
 .../SynchronizedMethod.java                   |  3 +-
 ...hronizedMethodAndBadVisibilityOnField.java |  3 +-
 .../VolatileField.java                        |  4 +-
 31 files changed, 85 insertions(+), 113 deletions(-)

diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
index a0fe7a7a8f1..9fefd554d05 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariablesTest.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -41,28 +40,28 @@ public void setup() {
     public void failurePath_fieldWithBadVisibility_whenOtherMethodHasSynchronizedBlock() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.class");
         assertSPVNumOfBugs(1);
-        assertSPVBug("SynchronizedBlockAndBadVisibilityOnField", "shutdown", 36);
+        assertSPVBug("SynchronizedBlockAndBadVisibilityOnField", "shutdown", 35);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenOtherMethodIsSynchronized() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.class");
         assertSPVNumOfBugs(1);
-        assertSPVBug("SynchronizedMethodAndBadVisibilityOnField", "shutdown", 36);
+        assertSPVBug("SynchronizedMethodAndBadVisibilityOnField", "shutdown", 35);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenClassExtendsThread() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.class");
         assertSPVNumOfBugs(1);
-        assertSPVBug("FieldWithBadVisibilityThread", "shutdown", 37);
+        assertSPVBug("FieldWithBadVisibilityThread", "shutdown", 36);
     }
 
     @Test
     public void failurePath_fieldWithBadVisibility_whenClassImplementsRunnable() {
         performAnalysis("multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.class");
         assertSPVNumOfBugs(1);
-        assertSPVBug("FieldWithBadVisibilityRunnable", "shutdown", 37);
+        assertSPVBug("FieldWithBadVisibilityRunnable", "shutdown", 36);
     }
 
     @Test
diff --git a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
index 09c7cd95268..8011f2386d8 100644
--- a/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
+++ b/spotbugs-tests/src/test/java/edu/umd/cs/findbugs/detect/FindCompoundOperationsOnSharedVariablesTest.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -60,7 +59,7 @@ public void happyPath_compoundOperationInsideSynchronizedMethod_onSharedVariable
     public void reportsBugFor_compoundPreDecrementation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundPreDecrementationOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundPreDecrementationOnSharedVariable", "getNum", 29);
     }
 
     // num--
@@ -68,7 +67,7 @@ public void reportsBugFor_compoundPreDecrementation_onSharedVariable() {
     public void reportsBugFor_compoundPostDecrementation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundPostDecrementationOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundPostDecrementationOnSharedVariable", "getNum", 29);
     }
 
     // ++num
@@ -76,7 +75,7 @@ public void reportsBugFor_compoundPostDecrementation_onSharedVariable() {
     public void reportsBugFor_compoundPreIncrementation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundPreIncrementationOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundPreIncrementationOnSharedVariable", "getNum", 29);
     }
 
     // num++
@@ -84,7 +83,7 @@ public void reportsBugFor_compoundPreIncrementation_onSharedVariable() {
     public void reportsBugFor_compoundPostIncrementation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundPostIncrementationOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundPostIncrementationOnSharedVariable", "getNum", 29);
     }
 
     // &=
@@ -92,7 +91,7 @@ public void reportsBugFor_compoundPostIncrementation_onSharedVariable() {
     public void reportsBugFor_compoundIAND_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundIANDOperationOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundIANDOperationOnSharedVariable", "getNum", 29);
     }
 
     // |=
@@ -100,7 +99,7 @@ public void reportsBugFor_compoundIAND_onSharedVariable() {
     public void reportsBugFor_compoundIOR_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundIOROperationOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundIOROperationOnSharedVariable", "getNum", 29);
     }
 
     // >>>=
@@ -108,7 +107,7 @@ public void reportsBugFor_compoundIOR_onSharedVariable() {
     public void reportsBugFor_compoundLogicalRightShifting_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundLogicalRightShiftingOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundLogicalRightShiftingOnSharedVariable", "getNum", 29);
     }
 
     // >>=
@@ -116,7 +115,7 @@ public void reportsBugFor_compoundLogicalRightShifting_onSharedVariable() {
     public void reportsBugFor_compoundRightShifting_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundRightShiftingOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundRightShiftingOnSharedVariable", "getNum", 29);
     }
 
     // <<=
@@ -124,7 +123,7 @@ public void reportsBugFor_compoundRightShifting_onSharedVariable() {
     public void reportsBugFor_compoundLeftShifting_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundLeftShiftingOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundLeftShiftingOnSharedVariable", "getNum", 29);
     }
 
     // %=
@@ -132,7 +131,7 @@ public void reportsBugFor_compoundLeftShifting_onSharedVariable() {
     public void reportsBugFor_compoundModulo_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundModuloOnSharedVariable", "getNum", 31);
+        assertCOSVBug("CompoundModuloOnSharedVariable", "getNum", 30);
     }
 
     // *=
@@ -140,7 +139,7 @@ public void reportsBugFor_compoundModulo_onSharedVariable() {
     public void reportsBugFor_compoundMultiplication_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundMultiplicationOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundMultiplicationOnSharedVariable", "getNum", 29);
     }
 
     // /=
@@ -148,7 +147,7 @@ public void reportsBugFor_compoundMultiplication_onSharedVariable() {
     public void reportsBugFor_compoundDivision_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundDivisionOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundDivisionOnSharedVariable", "getNum", 29);
     }
 
     // -=
@@ -156,7 +155,7 @@ public void reportsBugFor_compoundDivision_onSharedVariable() {
     public void reportsBugFor_compoundSubtraction_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundSubtractionOnSharedVariable", "getNum", 30);
+        assertCOSVBug("CompoundSubtractionOnSharedVariable", "getNum", 29);
     }
 
 
@@ -165,7 +164,7 @@ public void reportsBugFor_compoundSubtraction_onSharedVariable() {
     public void reportsBugFor_compoundAddition_onSharedVolatileVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundAdditionOnSharedVolatileVariable", "getNum", 30);
+        assertCOSVBug("CompoundAdditionOnSharedVolatileVariable", "getNum", 29);
     }
 
     // ^=
@@ -173,7 +172,7 @@ public void reportsBugFor_compoundAddition_onSharedVolatileVariable() {
     public void reportsBugFor_compoundXOROperation_onSharedVariable() {
         performAnalysis("multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.class");
         assertCOSVNumOfBugs(1);
-        assertCOSVBug("CompoundXOROperationOnSharedVariable", "getFlag", 30);
+        assertCOSVBug("CompoundXOROperationOnSharedVariable", "getFlag", 29);
     }
 
     private void assertCOSVNumOfBugs(int num) {
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
index c3b4b078c80..f2c96747edb 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
index 255d624242a..d7b1daaaf41 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find bugs in Java programs
- * Copyright (C) 2003,2004 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -28,6 +27,7 @@
 import edu.umd.cs.findbugs.bcel.OpcodeStackDetector;
 import edu.umd.cs.findbugs.util.MultiThreadedCodeIdentifierUtils;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -39,6 +39,34 @@
 
 public class CompoundOperationsOnSharedVariables extends OpcodeStackDetector {
 
+    private static final List<Short> readOpCodes = Arrays.asList(Const.GETFIELD, Const.GETSTATIC,
+            Const.ALOAD, Const.ALOAD_0, Const.ALOAD_1, Const.ALOAD_2, Const.ALOAD_3,
+            Const.DLOAD, Const.DLOAD_0, Const.DLOAD_1, Const.DLOAD_2, Const.DLOAD_3,
+            Const.LLOAD, Const.LLOAD_0, Const.LLOAD_1, Const.LLOAD_2, Const.LLOAD_3,
+            Const.FLOAD, Const.FLOAD_0, Const.FLOAD_1, Const.FLOAD_2, Const.FLOAD_3,
+            Const.ILOAD, Const.ILOAD_0, Const.ILOAD_1, Const.ILOAD_2, Const.ILOAD_3,
+            Const.DALOAD, Const.LALOAD, Const.FALOAD, Const.IALOAD);
+
+    private static final List<Short> pushOpCodes = Arrays.asList(Const.DCONST_0, Const.DCONST_1,
+            Const.LCONST_0, Const.LCONST_1,
+            Const.FCONST_0, Const.FCONST_1, Const.FCONST_2,
+            Const.ICONST_0, Const.ICONST_1, Const.ICONST_2, Const.ICONST_3, Const.ICONST_4, Const.ICONST_5,
+            Const.LDC, Const.LDC_W, Const.LDC2_W);
+
+    private static final List<Short> possibleCompoundOperationOpCodes = Arrays.asList(
+            // +=,++,       -=,--       *=,         /=,         %=
+            Const.DADD, Const.DSUB, Const.DMUL, Const.DDIV, Const.DREM,
+            Const.FADD, Const.FSUB, Const.FMUL, Const.FDIV, Const.FREM,
+            Const.LADD, Const.LSUB, Const.LMUL, Const.LDIV, Const.LREM,
+            Const.IADD, Const.ISUB, Const.IMUL, Const.IDIV, Const.IREM,
+            // <<=,         >>=,        >>>=
+            Const.ISHL, Const.ISHR, Const.IUSHR,
+            Const.LSHL, Const.LSHR, Const.LUSHR,
+            // &=
+            Const.IAND, Const.LAND,
+            // |=, ^=
+            Const.IOR, Const.IXOR, Const.LOR, Const.LXOR);
+
     private final BugAccumulator bugAccumulator;
     private final Map<XMethod, List<XField>> compoundlyWrittenNotSecuredFieldsByMethods;
     private final Map<XMethod, List<XField>> readNotSecuredFieldsByMethods;
@@ -174,37 +202,14 @@ private List<XField> appendToList(XField field, List<XField> list) {
     }
 
     private boolean isReadOpCode(int opCode) {
-        return opCode == Const.GETFIELD || opCode == Const.GETSTATIC
-                || opCode == Const.ALOAD || opCode == Const.ALOAD_0 || opCode == Const.ALOAD_1 || opCode == Const.ALOAD_2 || opCode == Const.ALOAD_3
-                || opCode == Const.DLOAD || opCode == Const.DLOAD_0 || opCode == Const.DLOAD_1 || opCode == Const.DLOAD_2 || opCode == Const.DLOAD_3
-                || opCode == Const.LLOAD || opCode == Const.LLOAD_0 || opCode == Const.LLOAD_1 || opCode == Const.LLOAD_2 || opCode == Const.LLOAD_3
-                || opCode == Const.FLOAD || opCode == Const.FLOAD_0 || opCode == Const.FLOAD_1 || opCode == Const.FLOAD_2 || opCode == Const.FLOAD_3
-                || opCode == Const.ILOAD || opCode == Const.ILOAD_0 || opCode == Const.ILOAD_1 || opCode == Const.ILOAD_2 || opCode == Const.ILOAD_3
-                || opCode == Const.DALOAD || opCode == Const.LALOAD || opCode == Const.FALOAD || opCode == Const.IALOAD;
+        return readOpCodes.contains(Integer.valueOf(opCode).shortValue());
     }
 
     private boolean isPushConstant(int opCode) {
-        return opCode == Const.DCONST_0 || opCode == Const.DCONST_1
-                || opCode == Const.LCONST_0 || opCode == Const.LCONST_1
-                || opCode == Const.FCONST_0 || opCode == Const.FCONST_1 || opCode == Const.FCONST_2
-                || opCode == Const.ICONST_0 || opCode == Const.ICONST_1 || opCode == Const.ICONST_2 || opCode == Const.ICONST_3
-                || opCode == Const.ICONST_4
-                || opCode == Const.ICONST_5
-                || opCode == Const.LDC || opCode == Const.LDC_W || opCode == Const.LDC2_W;
+        return pushOpCodes.contains(Integer.valueOf(opCode).shortValue());
     }
 
     private boolean possibleCompoundOperation(int opCode) {
-        // +=, -=, *=, /=, %=, ++, --
-        return opCode == Const.DADD || opCode == Const.DSUB || opCode == Const.DMUL || opCode == Const.DDIV || opCode == Const.DREM
-                || opCode == Const.FADD || opCode == Const.FSUB || opCode == Const.FMUL || opCode == Const.FDIV || opCode == Const.FREM
-                || opCode == Const.LADD || opCode == Const.LSUB || opCode == Const.LMUL || opCode == Const.LDIV || opCode == Const.LREM
-                || opCode == Const.IADD || opCode == Const.ISUB || opCode == Const.IMUL || opCode == Const.IDIV || opCode == Const.IREM
-                // <<=, >>=, >>>=
-                || opCode == Const.ISHL || opCode == Const.ISHR || opCode == Const.IUSHR
-                || opCode == Const.LSHL || opCode == Const.LSHR || opCode == Const.LUSHR
-                // &=
-                || opCode == Const.IAND || opCode == Const.LAND
-                // |=, ^=
-                || opCode == Const.IOR || opCode == Const.IXOR || opCode == Const.LOR || opCode == Const.LXOR;
+        return possibleCompoundOperationOpCodes.contains(Integer.valueOf(opCode).shortValue());
     }
 }
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
index 270816e6421..0bf57331f8d 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/util/MultiThreadedCodeIdentifierUtils.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find bugs in Java programs
- * Copyright (C) 2003,2004 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -45,11 +44,8 @@ public class MultiThreadedCodeIdentifierUtils {
 
     public static boolean isPartOfMultiThreadedCode(ClassContext classContext) {
         JavaClass classToCheck = classContext.getJavaClass();
-        if (implementsRunnable(classToCheck)) {
-            return true;
-        }
-
-        if (Stream.of(classToCheck.getFields()).anyMatch(MultiThreadedCodeIdentifierUtils::isFieldMultiThreaded)) {
+        if (implementsRunnable(classToCheck) ||
+                Stream.of(classToCheck.getFields()).anyMatch(MultiThreadedCodeIdentifierUtils::isFieldMultiThreaded)) {
             return true;
         }
 
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
index 5d6a493f389..fa171c61d18 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundAdditionOnSharedVolatileVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
index bd79d52e0ea..c2e83a68ea9 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundDivisionOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
index 0f685a85dcd..0f3027b4183 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIANDOperationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
index 04e34ef7369..84760a2854e 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundIOROperationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
index 4b80bfd2501..665b85706fd 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLeftShiftingOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
index 858b98d1441..5689cb521e4 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundLogicalRightShiftingOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
index d06c12397a4..a7dd19956eb 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundModuloOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
index a18a0c8b2bb..09ff2f55bbd 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundMultiplicationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
index 4e38b13120d..9c11e34fd3e 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundOperationOnSharedAtomicVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
index edf4fc704c4..51373f95425 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostDecrementationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
index d7c2637d6bb..79e55a66ee9 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPostIncrementationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
index 1c353f5ddfc..c81a7d5d14f 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreDecrementationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
index a4b09c1f82b..bbedc34c496 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundPreIncrementationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
index 2d42ed9e50e..dcfec04ed14 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundRightShiftingOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
index eacfb94c36c..28b10109788 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundSubtractionOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
index 1c63dccf4d4..1e1f909aac4 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/CompoundXOROperationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
index 5a3c8692749..551fc3b5018 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedBlockCompoundOperationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
index a9cb881d2ba..e67be3df205 100644
--- a/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
+++ b/spotbugsTestCases/src/java/multithreaded/compoundOperationOnSharedVariables/SynchronizedMethodCompoundOperationOnSharedVariable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
index 66f3165c88b..57a04cb38d5 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/AtomicField.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
index 7c851ad3ffd..2ee6c0a1ab8 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityRunnable.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
index 88715d9289c..abafd1e7c97 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/FieldWithBadVisibilityThread.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
index ef6cbd09f65..d73b98fdec5 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlock.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -17,6 +16,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+
 package multithreaded.sharedPrimitiveVariables;
 
 public class SynchronizedBlock implements Runnable {
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
index 0b634919681..eeb34a654f3 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedBlockAndBadVisibilityOnField.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
index 48fce78e0d6..ae48d9f4a38 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethod.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
index 90d7744582a..dfeff020e8c 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/SynchronizedMethodAndBadVisibilityOnField.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
diff --git a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
index 3ee53b574d6..ce6fa927431 100644
--- a/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
+++ b/spotbugsTestCases/src/java/multithreaded/sharedPrimitiveVariables/VolatileField.java
@@ -1,6 +1,5 @@
 /*
- * FindBugs - Find Bugs in Java programs
- * Copyright (C) 2003-2008 University of Maryland
+ * SpotBugs - Find bugs in Java programs
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -16,7 +15,6 @@
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
-
 package multithreaded.sharedPrimitiveVariables;
 
 public class VolatileField {

From a7efab46f68926a0c987970a814ae1ce922c867e Mon Sep 17 00:00:00 2001
From: gonczmisi <gonczmisi@gmail.com>
Date: Mon, 24 Oct 2022 19:47:44 +0200
Subject: [PATCH 7/8] Missing diamond operators, fixed misuse of Optional type

---
 ...dVisibilityOnSharedPrimitiveVariables.java |  4 +-
 .../CompoundOperationsOnSharedVariables.java  | 44 +++++++++----------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
index f2c96747edb..c175f40c246 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/BadVisibilityOnSharedPrimitiveVariables.java
@@ -61,8 +61,8 @@ public class BadVisibilityOnSharedPrimitiveVariables extends OpcodeStackDetector
 
     public BadVisibilityOnSharedPrimitiveVariables(BugReporter bugReporter) {
         this.bugAccumulator = new BugAccumulator(bugReporter);
-        this.modifiedNotSecuredFieldsByMethods = new HashMap();
-        this.comparedNotSecuredFieldsByMethods = new HashMap();
+        this.modifiedNotSecuredFieldsByMethods = new HashMap<>();
+        this.comparedNotSecuredFieldsByMethods = new HashMap<>();
         this.isInsideSynchronizedOrLockingMethod = false;
     }
 
diff --git a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
index d7b1daaaf41..d89957255ad 100644
--- a/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
+++ b/spotbugs/src/main/java/edu/umd/cs/findbugs/detect/CompoundOperationsOnSharedVariables.java
@@ -71,15 +71,15 @@ public class CompoundOperationsOnSharedVariables extends OpcodeStackDetector {
     private final Map<XMethod, List<XField>> compoundlyWrittenNotSecuredFieldsByMethods;
     private final Map<XMethod, List<XField>> readNotSecuredFieldsByMethods;
     private boolean isInsideSynchronizedOrLockingMethod;
-    private Optional<XField> maybeCompoundlyOperatedField;
+    private XField maybeCompoundlyOperatedField;
     private int stepsMadeInCompoundOperationProcess;
 
     public CompoundOperationsOnSharedVariables(BugReporter bugReporter) {
         this.bugAccumulator = new BugAccumulator(bugReporter);
-        this.compoundlyWrittenNotSecuredFieldsByMethods = new HashMap();
-        this.readNotSecuredFieldsByMethods = new HashMap();
+        this.compoundlyWrittenNotSecuredFieldsByMethods = new HashMap<>();
+        this.readNotSecuredFieldsByMethods = new HashMap<>();
         this.isInsideSynchronizedOrLockingMethod = false;
-        this.maybeCompoundlyOperatedField = Optional.empty();
+        this.maybeCompoundlyOperatedField = null;
         this.stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
     }
 
@@ -98,7 +98,7 @@ public void visitAfter(JavaClass obj) {
     public void visitClassContext(ClassContext classContext) {
         if (MultiThreadedCodeIdentifierUtils.isPartOfMultiThreadedCode(classContext)) {
             isInsideSynchronizedOrLockingMethod = false;
-            maybeCompoundlyOperatedField = Optional.empty();
+            maybeCompoundlyOperatedField = null;
             stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
 
             super.visitClassContext(classContext);
@@ -110,9 +110,9 @@ public void sawOpcode(int seen) {
         if (!isInsideSynchronizedOrLockingMethod) {
             if (seen == Const.GETFIELD || seen == Const.GETSTATIC) {
                 XMethod readMethod = getXMethod();
-                Optional<XField> maybeFieldToRead = Optional.ofNullable(getXFieldOperand());
-                lookForUnsecuredOperationsOnFieldInOtherMethods(
-                        maybeFieldToRead, readMethod, compoundlyWrittenNotSecuredFieldsByMethods, readNotSecuredFieldsByMethods);
+                XField maybeFieldToRead = getXFieldOperand();
+                lookForUnsecuredOperationsOnFieldInOtherMethods(maybeFieldToRead, readMethod,
+                        compoundlyWrittenNotSecuredFieldsByMethods, readNotSecuredFieldsByMethods);
                 maybeCompoundlyOperatedField = maybeFieldToRead;
                 stepsMadeInCompoundOperationProcess = 1;
                 return;
@@ -145,52 +145,52 @@ public void sawOpcode(int seen) {
 
             if (stepsMadeInCompoundOperationProcess == 3 && (seen == Const.PUTFIELD || seen == Const.PUTSTATIC)) {
                 XMethod modificationMethod = getXMethod();
-                Optional<XField> maybeFieldToModify = Optional.ofNullable(getXFieldOperand());
+                XField maybeFieldToModify = getXFieldOperand();
 
-                boolean matchWithReadField = maybeCompoundlyOperatedField
-                        .map(compoundlyOperatedField -> maybeFieldToModify
+                boolean matchWithReadField = Optional.ofNullable(maybeCompoundlyOperatedField)
+                        .map(compoundlyOperatedField -> Optional.ofNullable(maybeFieldToModify)
                                 .map(modifiedField -> modifiedField.getName().equals(compoundlyOperatedField.getName()))
                                 .orElse(false))
                         .orElse(false);
                 if (matchWithReadField) {
                     lookForUnsecuredOperationsOnFieldInOtherMethods(
-                            maybeFieldToModify, modificationMethod, readNotSecuredFieldsByMethods, compoundlyWrittenNotSecuredFieldsByMethods);
+                            maybeFieldToModify, modificationMethod, readNotSecuredFieldsByMethods,
+                            compoundlyWrittenNotSecuredFieldsByMethods);
 
                 }
 
-                maybeCompoundlyOperatedField = Optional.empty();
+                maybeCompoundlyOperatedField = null;
                 stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
             }
         } else {
-            maybeCompoundlyOperatedField = Optional.empty();
+            maybeCompoundlyOperatedField = null;
             stepsMadeInCompoundOperationProcess = Const.UNDEFINED;
         }
     }
 
     private void lookForUnsecuredOperationsOnFieldInOtherMethods(
-            Optional<XField> maybeField, XMethod operatingMethod,
+            XField maybeField, XMethod operatingMethod,
             Map<XMethod, List<XField>> checkAgainstMap, Map<XMethod, List<XField>> putInMap) {
-        boolean isFieldSecured = maybeField
+        boolean isFieldSecured = Optional.ofNullable(maybeField)
                 .map(field -> MultiThreadedCodeIdentifierUtils.signatureIsFromAtomicPackage(field.getSignature())
                         || field.isFinal())
                 .orElse(true);
         if (!isFieldSecured) {
-            XField field = maybeField.get();
             boolean fieldIsDangerouslyUsedByOtherMethod = checkAgainstMap.entrySet().stream()
-                    .anyMatch(entry -> entry.getValue().contains(field) && entry.getKey() != operatingMethod);
+                    .anyMatch(entry -> entry.getValue().contains(maybeField) && entry.getKey() != operatingMethod);
             if (fieldIsDangerouslyUsedByOtherMethod) {
                 bugAccumulator.accumulateBug(
                         new BugInstance(this, "COSV_COMPOUND_OPERATIONS_ON_SHARED_VARIABLES", NORMAL_PRIORITY)
                                 .addClassAndMethod(this)
                                 .addMethod(operatingMethod)
-                                .addField(field)
-                                .addString(field.getName()),
+                                .addField(maybeField)
+                                .addString(maybeField.getName()),
                         this);
             } else {
                 boolean appendedExisting = putInMap.computeIfPresent(
-                        operatingMethod, (method, fields) -> appendToList(field, fields)) != null;
+                        operatingMethod, (method, fields) -> appendToList(maybeField, fields)) != null;
                 if (!appendedExisting) {
-                    putInMap.put(operatingMethod, new ArrayList(Collections.singletonList(field)));
+                    putInMap.put(operatingMethod, new ArrayList<>(Collections.singletonList(maybeField)));
                 }
             }
         }

From 3a607952eab539f23a946ff595eb3e8a7a11df52 Mon Sep 17 00:00:00 2001
From: gonczmisi <gonczmisi@gmail.com>
Date: Thu, 23 Feb 2023 21:33:15 +0100
Subject: [PATCH 8/8] Rephrased bugpattern details

---
 spotbugs/etc/messages.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/spotbugs/etc/messages.xml b/spotbugs/etc/messages.xml
index 39b49df34d5..2ebfa22ed57 100644
--- a/spotbugs/etc/messages.xml
+++ b/spotbugs/etc/messages.xml
@@ -8833,7 +8833,7 @@ Using floating-point variables should not be used as loop counters, as they are
           describes that compound operations on shared variables must be performed atomically to prevent data races and race conditions.
           Compound operations are operations that consist of more than one discrete operation. Expressions that include postfix or prefix increment (++), postfix or prefix decrement (--),
           or compound assignment operators always result in compound operations.
-          Important that declaring a variable volatile fails to guarantee the atomicity of compound operations on the variable.
+          It is important to note that declaring a variable volatile fails to guarantee the atomicity of compound operations on the variable.
         <p>
           To solve this issue, synchronize compound operations, use read-write locks, or declare these shared variables with an atomic type.
         </p>