assertThrows(NullPointerException.class, () -> getMap().replace(k0(), v0(), null));
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUE_QUERIES)
  @CollectionSize.Require(absent = ZERO)
  public void testReplaceEntry_wrongValueNullValueUnsupported() {
    try {
      assertFalse(getMap().replace(k0(), v3(), null));
    } catch (NullPointerException tolerated) {

    assertThrows(NullPointerException.class, () -> getMap().replace(k0(), v0(), null));
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUE_QUERIES)
  @CollectionSize.Require(absent = ZERO)
  public void testReplaceEntry_wrongValueNullValueUnsupported() {
    try {
      assertFalse(getMap().replace(k0(), v3(), null));
    } catch (NullPointerException tolerated) {

     * Do not instantiate.
     */
    protected ModifierUtil() {
    }

    /**
     * Checks if the specified method is public.
     *
     * @param method
     *            the method to check. Must not be null.
     * @return true if public, false otherwise
     */
    public static boolean isPublic(final Method method) {
        assertArgumentNotNull("method", method);

        return isPublic(method.getModifiers());
    }

        String msg = req.getHeader("Authorization");
        if (msg != null && msg.startsWith("NTLM ")) {
            final byte[] src = Base64.decode(msg.substring(5));
            if (src[8] == 1) {
                final Type1Message type1 = new Type1Message(src);
                final Type2Message type2 = new Type2Message(type1, challenge, null);
                msg = Base64.encode(type2.toByteArray());

        // writeString adds null terminator
        assertTrue(len > 2, "Length should include path");
        String writtenPath = extractStringFromBuffer(buffer, 2, len - 2);
        assertTrue(writtenPath.contains("abc"), "Path should be written to buffer");
    }

    @Test
    @DisplayName("writeParametersWireFormat throws on null path")
    void testNullPath() {

    @NotBlank
    public String confirmNewPassword;

    /**
     * Clears security information.
     */
    public void clearSecurityInfo() {
        oldPassword = null;
        newPassword = null;
        confirmNewPassword = null;
    }

  private static final Object OBJECT = new Object();

  public void testNewReference() throws Exception {
    assertEquals(null, Atomics.newReference().get());
  }

  public void testNewReference_withInitialValue() throws Exception {
    assertEquals(null, Atomics.newReference(null).get());
    assertEquals(OBJECT, Atomics.newReference(OBJECT).get());
  }

  public void testNewReferenceArray_withLength() throws Exception {

        return toBigDecimal(o, null);
    }

    /**
     * Converts to {@link BigDecimal}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link BigDecimal}
     */
    public static BigDecimal toBigDecimal(final Object o, final String pattern) {
        if (o == null) {
            return null;

     *
     * @param session The repository session, must not be {@code null}.
     * @param artifactCoordinates The artifact coordinates for which the version needs to be resolved, must not be {@code null}
     * @return The version result, never {@code null}.
     * @throws VersionResolverException If the metaversion could not be resolved.
     */
    @Nonnull

    assertEquals(getMethodName() + "(nullNotPresent) should return -1", -1, find(null));
  }

  @CollectionFeature.Require(absent = ALLOWS_NULL_VALUES)
  public void testFind_nullNotContainedAndUnsupported() {
    try {
      assertEquals(getMethodName() + "(nullNotPresent) should return -1 or throw", -1, find(null));
    } catch (NullPointerException tolerated) {
    }
  }