this.suppressThrows = suppressThrows;
  }

  @Override
  public final void addTearDown(TearDown tearDown) {
    synchronized (lock) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    Throwable exception = null;
    List<TearDown> stackCopy;
    synchronized (lock) {
      stackCopy = new ArrayList<>(stack);
      stack.clear();
    }

    /**
     * Constructs a new CrawlingAccessException with the specified detail message and cause.
     *
     * @param message the detail message
     * @param cause the cause
     */
    public CrawlingAccessException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new CrawlingAccessException with the specified detail message.
     *

        assertTrue(bulkLine.contains("reading2"));
    }

    @Test(expected = SuggesterException.class)
    public void testCreateBulkLineWithNullItem() {
        // Test that null item causes exception
        SuggestUtil.createBulkLine("test_index", "_doc", null);
    }

    @Test
    public void testCreateDefaultReadingConverter() {
        // Test creating default reading converter

        });

        // Test throwing and catching with cause
        RuntimeException cause = new RuntimeException("Cause");
        TransportException thrown = assertThrows(TransportException.class, () -> {
            throw new TransportException(cause);
        });
        assertEquals(cause, thrown.getCause());

        // Test throwing and catching with message and cause

     * @param count the number of misses to record
     * @since 11.0
     */
    void recordMisses(int count);

    /**
     * Records the successful load of a new entry. This should be called when a cache request causes
     * an entry to be loaded, and the loading completes successfully. In contrast to {@link
     * #recordMisses}, this method should only be called by the loading thread.
     *

        assertEquals(0, exception.getErrorCode(), "Error code should be 0 for message and cause constructor.");
        assertEquals(message, exception.getMessage(), "Message should match the input.");
        assertEquals(cause, exception.getCause(), "Cause should match the input.");
        assertEquals(cause, exception.getRootCause(), "getRootCause() should return the same cause as getCause().");
    }

    /**

    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();
    ExampleClassUnderTest.foo();
    for (LogRecord unused : handler.getStoredLogRecords()) {

    void testToStringWithRootCause() {
        RuntimeException cause = new RuntimeException("boom");
        SmbException ex = new SmbException(0, cause);
        assertTrue(ex.toString().contains("RuntimeException"), "String representation must include the root cause stack trace");
    }

    /**
     * Verify that {@link #toString()} with no root cause equals the default

        /* Samba has a tendency to return referral paths and pathConsumed values
         * in such a way that there can be a slash at the end of the path. This
         * causes problems matching keys in resolve() where an extra slash causes
         * a mismatch. This strips trailing slashes from all keys to eliminate
         * this problem.
         */
        int ki = key.length();

Do not remove `null` checks on public API boundaries, even if the annotations (or rather lack of them) suggest this.
Not all client code is compiled with NullAway.
Do not make a parameter `@Nullable` just to check and throw a `NullPointerException` when it is `null`. 

## Status

ACCEPTED

## Consequences

* Classes are forced to have consistent nullability annotations.