public void testSortedCopyOf_natural_containsNull() {
    Collection<@Nullable Integer> c = MinimalCollection.of(1, 3, null, 2);
    try {
      ImmutableList.sortedCopyOf((Collection<Integer>) c);
      fail("Expected NPE");
    } catch (NullPointerException expected) {
    }
  }

  public void testSortedCopyOf() {
    Collection<String> c = MinimalCollection.of("a", "b", "A", "c");

            println "Retrying cross version test because of <1.3 daemon connection issue"
            return cleanProjectDir(specification)
        }

        // this is cause by a bug in Gradle <1.8, where a NPE is thrown when DaemonInfo is removed from the daemon registry by another process
        if (targetDistVersion < GradleVersion.version("1.8") &&

    //  it is explicitly spelled, e.g.
    //  Try<String> t = Try.successful("some")
    //  t.get().length()  // IDEA produces false positive "potential NPE" warning when JB annotations are used.
    //  Kotlin understands it correctly, though. JSpecify annotations of version 0.3 seem to work well too.
    private Try() {
    }

    /**

			conditionType:   apps.DeploymentProgressing,
			conditionStatus: v1.ConditionTrue,
			conditionReason: util.NewRSAvailableReason,
		},
		{
			name:            "DeploymentComplete: defend against NPE when newRS=nil",
			d:               currentDeployment(&pds, 0, 3, 3, 3, []apps.DeploymentCondition{replicaSetUpdated}),
			allRSs:          []*apps.ReplicaSet{newRSWithAvailable("foo", 0, 0, 0)},

  public void testConstructor() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
      assertBitEquals(0.0, aa.get(i));
    }
  }

  /** constructor with null array throws NPE */
  public void testConstructor2NPE() {
    double[] a = null;
    assertThrows(NullPointerException.class, () -> new AtomicDoubleArray(a));
  }

  /** constructor with array is of same size and has all elements */

- [`KT-67144`](https://youtrack.jetbrains.com/issue/KT-67144) K2: potential NPE when assigning to unstable vars
- [`KT-66971`](https://youtrack.jetbrains.com/issue/KT-66971) K2: missing SMARTCAST_IMPOSSIBLE on open val declared in another module
- [`KT-66904`](https://youtrack.jetbrains.com/issue/KT-66904) K2: possible NPE when reassigning captured variables

    if (ownerType == null) {
      return newParameterizedType(rawType, arguments);
    }
    // ParameterizedTypeImpl constructor already checks, but we want to throw NPE before IAE
    checkNotNull(arguments);
    checkArgument(rawType.getEnclosingClass() != null, "Owner type for unenclosed %s", rawType);
    return new ParameterizedTypeImpl(ownerType, rawType, arguments);
  }

    // Pretend the comparator can compare anything. If it turns out it can't
    // compare a and b, we should get a CCE or NPE on the subsequent line. Only methods
    // that are spec'd to throw CCE and NPE should call this.
    @SuppressWarnings({"unchecked", "nullness"})
    Comparator<@Nullable Object> unsafeComparator = (Comparator<@Nullable Object>) comparator;

    // Pretend the comparator can compare anything. If it turns out it can't
    // compare a and b, we should get a CCE or NPE on the subsequent line. Only methods
    // that are spec'd to throw CCE and NPE should call this.
    @SuppressWarnings({"unchecked", "nullness"})
    Comparator<@Nullable Object> unsafeComparator = (Comparator<@Nullable Object>) comparator;

        return delegate.hashCode();
    }

    @Nullable
    private Object getAndReportAccess(@Nullable Object key) {
        Object value = delegate.get(key);
        // delegate.get(null) actually throws NPE.
        assert key != null;
        reportAccess(key, value);
        return value;
    }

    private void reportAccess(Object key, @Nullable Object value) {
        listener.onAccess(key, value);
    }