return entryIterator.hasNext();
      }

      @Override
      public K next() {
        return entryIterator.next().getKey();
      }
    };
  }

  Spliterator<K> keySpliterator() {
    return CollectSpliterators.map(entrySet().spliterator(), Entry::getKey);
  }

  @LazyInit @RetainedWith private transient @Nullable ImmutableCollection<V> values;

  /**

            }

            String result = template;
            if (paramMap != null) {
                for (Map.Entry<String, Object> entry : paramMap.entrySet()) {
                    String key = entry.getKey();
                    Object value = entry.getValue();

                    // Handle nested properties
                    if (key.contains(".")) {
                        // Simple nested property handling for testing

public class CustomSizeTest extends UnitFessTestCase {

    // Test field with CustomSize annotation for testing
    @CustomSize(minKey = "test.min", maxKey = "test.max")
    private String testField;

    // Test field with only minKey
    @CustomSize(minKey = "test.min.only")
    private String testFieldMinOnly;

    // Test field with only maxKey
    @CustomSize(maxKey = "test.max.only")

            }).forEach(e -> {
                if (logger.isDebugEnabled()) {
                    logger.debug("system.properties: setProperty({}, {})", e.getKey(), e.getValue());
                }
                System.setProperty(e.getKey(), e.getValue());
            });
        }
    }

    /**
     * Updates the application configuration.
     *

        }
        this.headerFields = null;
        for (final Entry<String, List<String>> property : this.connection.getRequestProperties().entrySet()) {
            final String key = property.getKey();
            final StringBuilder value = new StringBuilder();
            final Iterator<String> values = property.getValue().iterator();
            while (values.hasNext()) {
                value.append(values.next());

                    Map<String, String> map = CompactHashMap.create();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })
            .named("CompactHashMap")
            .withFeatures(
                CollectionSize.ANY,

            for (Entry<Range<Integer>, Integer> entry : rangeMap.asMapOfRanges().entrySet()) {
              if (entry.getKey().isConnected(subRange)
                  && !entry.getKey().intersection(subRange).isEmpty()) {
                expectedBuilder.put(entry.getKey().intersection(subRange), entry.getValue());
              }
            }

    @Test
    public void testEntrySet() throws Exception {
        Iterator<Map.Entry<String, String>> i = map.entrySet().iterator();
        assertThat(i.next().getKey(), is(nullValue()));
        assertThat(i.next().getKey(), is("1"));
        assertThat(i.next().getKey(), is("2"));
    }

    /**
     * Test method for {@link org.seasar.util.collection.ArrayIterator#remove()}
     * .
     */
    @Test

            // Create new lease
            Smb2LeaseKey newKey = new Smb2LeaseKey();
            LeaseEntry newEntry = new LeaseEntry(newKey, path, requestedState);
            leases.put(newKey, newEntry);
            pathToLease.put(path, newKey);

            log.debug("Created new lease for path: {} with key: {}", path, newKey);
            return newKey;
        } finally {
            lock.writeLock().unlock();

                          return next.getValue();
                        }

                        @Override
                        public String getKey() {
                          return next.getKey();
                        }

                        @Override
                        public boolean equals(@Nullable Object obj) {
                          return next.equals(obj);