# ADR-0008 - Use NullAway for null checking

## Date

2025-08-06

## Context

Our codebase uses `null` extensively to represent an absence of value or optionality of the argument.
We utilize nullness annotations in Java code and somewhat rely on IDE warnings to guide us.
However, the Java code we have is not fully annotated, which causes several consequences:
* IDE warnings can be misleading

        // Test presence of flags
        assertTrue((flags & SecurityInfo.OWNER_SECURITY_INFO) != 0);
        assertTrue((flags & SecurityInfo.DACL_SECURITY_INFO) != 0);

        // Test absence of flags
        assertTrue((flags & SecurityInfo.GROUP_SECURITY_INFO) == 0);
        assertTrue((flags & SecurityInfo.SACL_SECURITY_INFO) == 0);
    }

    @Test
    @DisplayName("Test interface extends Decodable")

    assertEquals("message", record.getMessage());
    assertSame(EXCEPTION, record.getThrown());
  }

  public void testConcurrentModification() throws Exception {
    // Tests for the absence of a bug where logging while iterating over the
    // stored log records causes a ConcurrentModificationException
    assertTrue(handler.getStoredLogRecords().isEmpty());
    ExampleClassUnderTest.foo();

  }

  /** Equivalent to {@code add(-1)}. */
  public void decrement() {
    add(-1L);
  }

  /**
   * Returns the current sum. The returned value is NOT an atomic snapshot; invocation in
   * the absence of concurrent updates returns an accurate result, but concurrent updates that occur
   * while the sum is being calculated might not be incorporated.
   *
   * @return the sum
   */
  @Override
  public long sum() {

   * AbstractListTester isn't enough because many tests that run on lists don't
   * extends AbstractListTester.) We could also iterate over all elements to
   * verify absence
   */
  protected void expectMissing(E... elements) {
    for (E element : elements) {
      assertFalse("Should not contain " + element, actualContents().contains(element));
    }
  }

 * a traditional {@code HashMap} implementation which stores keys and count values as map entries,
 * {@code ObjectCountHashMap} minimizes object allocation and reduces memory footprint.
 *
 * <p>In the absence of element deletions, this will iterate over elements in insertion order.
 */
@GwtCompatible
@NullMarked
class ObjectCountHashMap<K extends @Nullable Object> {

                && !this.mechContext.isPreferredMech(this.selectedMech)) {
            throw new CIFSException("SPNEGO integrity is required but not available");
        }

        // otherwise we ignore the absence of a MIC
        if (!this.mechContext.isMICAvailable() || mechanismListMIC == null) {
            return;
        }

        try {
            final ASN1ObjectIdentifier[] lm = this.mechs;

    modifications of Covered Software, or (ii) the combination of its
    Contributions with other software (except as part of its Contributor
    Version); or

(c) under Patent Claims infringed by Covered Software in the absence of
    its Contributions.

This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).

    
    SmbSession session = new SmbSession(context, transport);
    session.initializeWitnessSupport();
    
    // Should either find witness service or gracefully handle absence
    // No exception should be thrown
}

private static class TestWitnessListener implements WitnessClient.WitnessNotificationListener {
    private volatile boolean notificationReceived = false;

unless all the accesses involved are atomic data accesses as provided by the <code>sync/atomic</code> package.
As noted already, programmers are strongly encouraged to use appropriate synchronization
to avoid data races.
In the absence of data races, Go programs behave as if all the goroutines
were multiplexed onto a single processor.
This property is sometimes referred to as DRF-SC: data-race-free programs
execute in a sequentially consistent manner.
</p>