@Override
            protected SmbResource adapt(FileEntry e) throws MalformedURLException {
                return null;
            }
        };

        // When all entries return null, iterator should be empty
        assertFalse(iterator.hasNext());
        assertNull(iterator.next());
    }

    assertEquals("correct", f.apply(new Object()));
    assertEquals("correct", f.apply(null));

    Function<@Nullable Object, @Nullable String> g = Functions.constant(null);
    assertEquals(null, g.apply(2));
    assertEquals(null, g.apply(null));

    new EqualsTester()
        .addEqualityGroup(f, Functions.constant("correct"))

  /**
   * The reason why this stream was closed, or null if it closed normally or has not yet been
   * closed.
   *
   * If there are multiple reasons to abnormally close this stream (such as both peers closing it
   * near-simultaneously) then this is the first reason known to this peer.
   */
  internal var errorCode: ErrorCode? = null
    get() = withLock { field }

  public void testContainsEntryNullYes() {
    initMultimapWithNullKeyAndValue();
    assertTrue(multimap().containsEntry(null, null));
  }

  @MapFeature.Require({ALLOWS_NULL_KEY_QUERIES, ALLOWS_NULL_VALUE_QUERIES})
  public void testContainsEntryNullNo() {
    assertFalse(multimap().containsEntry(null, null));
  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEY_QUERIES)

             * is serviced. The alternative complicates things
             * more than I think is worth it.
             */

            if (socket != null) {
                socket.close();
                socket = null;
            }
            thread = null;
            responseTable.clear();
        }
    }

    @Override
    public void run() {
        int nameTrnId;

     */
    protected static DcerpcBinding parseBinding(final String str) throws DcerpcException {
        int state, mark, si;
        final char[] arr = str.toCharArray();
        String proto = null, key = null;
        DcerpcBinding binding = null;

        state = mark = si = 0;
        do {
            final char ch = arr[si];

            switch (state) {
            case 0:
                if (ch == ':') {

    assertTrue(multimap().putAll(k0(), newArrayList(v3(), null)));
    assertGet(k0(), v0(), v3(), null);
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  public void testPutAllNullValueOnAbsentKey_supported() {
    assertTrue(multimap().putAll(k3(), newArrayList(v3(), null)));
    assertGet(k3(), v3(), null);
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUES)

```

### Type Conversion
```java
import org.codelibs.core.convert.*;

// Safe type conversions with null handling
Integer value = IntegerConversionUtil.toInteger("123");        // Returns 123
Integer nullValue = IntegerConversionUtil.toInteger(null);     // Returns null
Boolean flag = BooleanConversionUtil.toBoolean("true");        // Returns true
Date date = DateConversionUtil.toDate("2023-12-25", "yyyy-MM-dd");

            long id = 0;
            String line = null;
            while ((line = reader.readLine()) != null) {
                if (line.length() == 0 || line.charAt(0) == '#') {
                    if (updater != null) {
                        updater.write(line);
                    }
                    continue; // ignore empty lines and comments

        byte[] encrypted = storage.encryptCredentials(null);
        assertNull(encrypted, "Encrypting null should return null");

        char[] decrypted = storage.decryptCredentials(null);
        assertNull(decrypted, "Decrypting null should return null");
    }

    @Test
    public void testEncryptDecryptLongPassword() throws Exception {
        // Test with very long password