// GWT's TreeMap.entrySet().removeAll(null) doesn't throws NPE.
    }
  }

  @Override
  public void testEntrySetRetainAllNullFromEmpty() {
    try {
      super.testEntrySetRetainAllNullFromEmpty();
    } catch (RuntimeException tolerated) {
      // GWT's TreeMap.entrySet().retainAll(null) doesn't throws NPE.
    }
  }

  @Override
  public void testKeySetRemoveAllNullFromEmpty() {

    public void oneArg(String s) {
      // Fail:  missing NPE for s
    }
  }

  public void testFailOneArgDoesntThrowNpe() {
    shouldFail(new FailOneArgDoesntThrowNPE());
  }

  private static class FailOneArgThrowsWrongType extends PassObject {
    @Override
    public void oneArg(String s) {
      doThrow(s); // Fail:  throwing non-NPE exception for null s
    }
  }

apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
releaseNotes:
  - |

class ExceptionMetadataHelperTest extends Specification {

    void "extracts exception with multiple cause chain"() {
        given:
        def npe = new NullPointerException("nullness")
        def iae = new IllegalArgumentException("badness", npe)
        def re = new RuntimeException("sadness")
        def mbf = new MultipleBuildFailures([re, iae])

        expect:

    @Override
    public Artifact find(Artifact artifact) {
        File artifactFile = new File(localRepository.getBasedir(), pathOf(artifact));

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        return artifact;
    }

    @Override
    public String getId() {

        then:
        parsed instanceof URI
    }

    def "does not throw NPE for URI with unknown schema"() {
        setup:
        def unsupportedURIString = new URI("no-schema")
        when:
        def parsed = parse(unsupportedURIString)
        then:
        parsed instanceof URI
    }

    def "does not throw NPE for non-hierarchical URI"() {
        setup:

    }

    def "Adding zero JVM arguments is a no-op"() {
        expect:
        loadBuildEnvironment { builder -> builder.addJvmArguments() }
    }

    def "Adding null JVM argument throws NPE"() {
        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as String) }

        then:
        thrown(NullPointerException)

        when:

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class BuildFailureIntegrationTest extends AbstractIntegrationSpec {
    def "still prints errors when exception misbehaves"() {
        // When running in-process, the NPE propagates out of the test fixtures
        executer.requireIsolatedDaemons()
        executer.requireDaemon()

        buildFile << """
class BadException extends Exception {
   String getMessage() {

    /** Constructor for use by subclasses. */
    public StandardKeySet() {
      super(ForwardingSortedMap.this);
    }
  }

  // unsafe, but worst case is a CCE or NPE is thrown, which callers will be expecting
  @SuppressWarnings({"unchecked", "nullness"})
  static int unsafeCompare(
      @CheckForNull Comparator<?> comparator, @CheckForNull Object o1, @CheckForNull Object o2) {

            }

            task resolve {
                inputs.files(configurations.conf)
            }
        """
        expect:
        // When this has failed in the past, building the task graph hits a NPE from the attribute container
        succeeds("resolve")
    }