element.input = unescape(parts[i++])

        val base = if (i < parts.size) parts[i++] else null
        element.base =
          when {
            base == null || base.isEmpty() -> list[list.size - 1].base
            else -> unescape(base)
          }

        while (i < parts.size) {
          val piece = parts[i]
          if (piece.startsWith("#")) {
            i++
            continue

        }
        if (size > maxSize) {
            throw new IllegalArgumentException(fieldName + " size exceeds maximum (" + maxSize + "): " + size);
        }
    }

    /**
     * Validates buffer size for SMB2/3
     *
     * @param size the buffer size to validate
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if size is invalid
     */

      newDelegate.addAll(delegate);
      this.table = newDelegate;
      return;
    }
    int size = this.size;
    if (size < requireEntries().length) {
      resizeEntries(size);
    }
    int minimumTableSize = CompactHashing.tableSize(size);
    int mask = hashTableMask();
    if (minimumTableSize < mask) { // smaller table size will always be less than current mask

    }

    /**
     * Set the maximum pool size
     * @param size the maximum number of connections in the pool
     */
    public void setMaxPoolSize(int size) {
        if (size <= 0) {
            throw new IllegalArgumentException("Pool size must be positive");
        }
        this.maxPoolSize = size;
        log.info("Set maximum pool size to {}", size);
    }

    /**

        assertEquals(expectedSize, request.size());
    }

    @Test
    @DisplayName("Test size calculation with empty path")
    void testSizeWithEmptyPath() {
        request = new Smb2CreateRequest(mockConfig, "");

        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 56;
        expectedSize += 8; // size8(1) - empty name gets 1 byte
        expectedSize = ((expectedSize + 7) / 8) * 8; // size8(size)

     */
    public void setIndex(final String index) {
        this.index = index;
    }

    /**
     * Sets the size of results.
     * @param size The size.
     */
    public void setSize(final int size) {
        this.size = size;
    }

    /**
     * Sets the query string.
     * @param query The query string.
     */
    public void setQuery(final String query) {

  private void assertCollectionSize(Collection<?> collection, int size) {
    assertThat(collection.size()).isEqualTo(size);
    if (size > 0) {
      assertThat(collection.isEmpty()).isFalse();
    } else {
      assertThat(collection.isEmpty()).isTrue();
    }
    assertThat(Iterables.size(collection)).isEqualTo(size);
    assertThat(Iterators.size(collection.iterator())).isEqualTo(size);
  }

			rs.set(ri.Arn, ri.Size, 0, status, ri.OpType, ri.endpoint, ri.secure, ri.Err)
		}
	case replication.Completed:
		if ri.OpType.IsDataReplication() {
			rs.set(ri.Arn, ri.Size, ri.Duration, status, ri.OpType, ri.endpoint, ri.secure, ri.Err)
		}
	case replication.Failed:
		if ri.OpType.IsDataReplication() && prevStatus == replication.Pending {

        return this;
    }

    /**
     * Gets the fragment size.
     *
     * @return the fragment size in characters
     */
    public int getFragmentSize() {
        return fragmentSize;
    }

    /**
     * Sets the fragment size with fluent interface.
     *
     * @param fragmentSize the fragment size in characters
     * @return this HighlightInfo instance for method chaining
     */

  @BeforeExperiment
  void setUp() {
    checkArgument(size > 0, "empty collection not supported");
    Set<Integer> set = new LinkedHashSet<>(size);

    Random random = new Random();
    while (set.size() < size) {
      set.add(random.nextInt());
    }
    List<Integer> list = new ArrayList<>(set);
    inputOrder.arrange(list);
    input = ImmutableList.copyOf(list);
  }

  @Benchmark
  int collections(int reps) {