public interface VersionParser extends Service {

    /**
     * Parses the specified version string, for example "1.0".
     *
     * @param version the version string to parse, must not be {@code null}
     * @return the parsed version, never {@code null}
     * @throws VersionParserException if the string violates the syntax rules of this scheme
     * @see org.apache.maven.api.Session#parseVersion(String)
     */
    @Nonnull

@GwtCompatible
final class CollectPreconditions {

  static void checkEntryNotNull(Object key, Object value) {
    if (key == null) {
      throw new NullPointerException("null key in entry: null=" + value);
    } else if (value == null) {
      throw new NullPointerException("null value in entry: " + key + "=null");
    }
  }

  @CanIgnoreReturnValue
  static int checkNonnegative(int value, String name) {
    if (value < 0) {

        verify(messageBlock).getDigest();
    }

    @Test
    @DisplayName("Test setDigest with null value")
    void testSetDigestWithNull() {
        // Given
        doNothing().when(messageBlock).setDigest(null);
        when(messageBlock.getDigest()).thenReturn(null);

        // When
        messageBlock.setDigest(null);
        SMBSigningDigest retrievedDigest = messageBlock.getDigest();

        // Then

                    break;
                }
            }
            if (this.authMethod == null) {
                return null;
            }
            NtlmMessage message = authorization != null ? new Type2Message(Base64.decode(authorization)) : null;
            reconnect();
            if (message == null) {
                message = new Type1Message(this.transportContext);

   *
   * @throws IllegalArgumentException if the stream consists of two or more elements.
   * @throws NullPointerException if any element in the stream is {@code null}.
   * @return {@code Optional.of(onlyElement)} if the stream has exactly one element (must not be
   *     {@code null}) and returns {@code Optional.empty()} if it has none.
   */
  @SuppressWarnings("unchecked")
  public static <T> Collector<T, ?, Optional<T>> toOptional() {

                }));
    expectReplacement(entry(getKeyForNullValue(), v3()));
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_KEYS})
  public void testMergeAbsentNullKey() {
    assertEquals(
        "Map.merge(null, value, function) should return value",
        v3(),
        getMap()
            .merge(
                null,
                v3(),

    public void test_nullHandling() {
        // Test with null ParseException
        QueryParseException queryParseException = new QueryParseException(null);
        assertNotNull(queryParseException);
        assertNull(queryParseException.getCause());
        // getMessage() may return null when constructed with null
        // This is expected behavior for exceptions with null cause
    }

    public void test_nestedCause() {

     * Constructs an instance.
     *
     * @param clazz
     *            the class (must not be {@literal null})
     */
    public ClassIterator(final Class<?> clazz) {
        this(clazz, true);
    }

    /**
     * Constructs an instance.
     *
     * @param clazz the class (must not be {@literal null})
     * @param includeObject if {@literal true}, includes the {@link Object} class in the iteration
     */

     * @param keyList The list of keys to register this extractor under.
     */
    public void register(final List<String> keyList) {
        if (keyList == null || keyList.isEmpty()) {
            throw new IllegalArgumentException("keyList must not be null or empty.");
        }
        getExtractorFactory().addExtractor(keyList, this);
    }

    /**
     * Returns the MimeTypeHelper instance from the CrawlerContainer.

     */
    public PACDecodingException() {
        this(null, null);
    }

    /**
     * Constructs a new PAC decoding exception with the specified detail message.
     * @param message the detail message
     */
    public PACDecodingException(final String message) {
        this(message, null);
    }

    /**
     * Constructs a new PAC decoding exception with the specified cause.