//     eviction callback, and TTL.
func New(size int, ttl time.Duration) Store {
	if size <= 0 {
		size = defaultMaxSize
	}

	if ttl <= 0 {
		ttl = defaultTTL
	}

	onEvicted := func(k string, v *Stmt) {
		if v != nil {
			go v.Close()
		}
	}
	return &lruStore{lru: lru.NewLRU[string, *Stmt](size, onEvicted, ttl)}
}

type lruStore struct {

  private var contentLength = -1L

  @get:JvmName("boundary")
  val boundary: String
    get() = boundaryByteString.utf8()

  /** The number of parts in this multipart body. */
  @get:JvmName("size")
  val size: Int
    get() = parts.size

  fun part(index: Int): Part = parts[index]

  override fun isOneShot(): Boolean = parts.any { it.body.isOneShot() }

  /** A combination of [type] and [boundaryByteString]. */

    assertEquals(underlying.size(), map.size());

    underlying.put("d", 4);
    assertEquals(underlying.size(), map.size());
    assertEquals("4", map.get("d"));

    underlying.remove("c");
    assertEquals(underlying.size(), map.size());
    assertFalse(map.containsKey("c"));

    underlying.clear();
    assertEquals(underlying.size(), map.size());
  }

    }

    @Test
    void testGetEntriesWithSingleShare() throws Exception {
        // Create a single ShareInfo1 object
        srvsvc.ShareInfo1 shareInfo = new srvsvc.ShareInfo1();
        shareInfo.netname = "SingleShare";
        shareInfo.type = 2;
        shareInfo.remark = "Single share remark";

        // Create ShareInfoCtr1 with one share

  @Throws(IOException::class)
  fun deflate(buffer: Buffer) {
    require(deflatedBytes.size == 0L)

    if (noContextTakeover) {
      deflater.reset()
    }

    deflaterSink.write(buffer, buffer.size)
    deflaterSink.flush()

    if (deflatedBytes.endsWith(EMPTY_DEFLATE_BLOCK)) {
      val newSize = deflatedBytes.size - LAST_OCTETS_COUNT_TO_REMOVE_AFTER_DEFLATION
      deflatedBytes.readAndWriteUnsafe().use { cursor ->

    }

    // Edge/null/empty: message-only constructor should propagate message and set unsuccessful status
    @ParameterizedTest
    @NullSource
    @ValueSource(strings = { "", " ", "simple", "with unicode Ω≈ç√", "long-0123456789-abcdefghijklmnopqrstuvwxyz" })
    @DisplayName("Message-only ctor: propagates message and unsuccessful status")
    void messageOnlyConstructor_setsMessage_andUnsuccessfulStatus(String msg) {

        But Guava aims to provide functionality that is useful across boundaries of projects,
        companies, or even industries — utilities useful for a sizable proportion of all Java
        programmers everywhere. If you can give enough detail such that any of us can imagine coming
        across a similar need in our own work, that's extremely helpful in studying how broadly

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size() {
        int size = Smb2Constants.SMB2_HEADER_LENGTH + 40;
        if (this.inputBuffer != null) {
            size += this.inputBuffer.size();
        }
        return size8(size);
    }

    /**
     * {@inheritDoc}
     *

    private static boolean removeLastDuplication(final StringBuilder buf, final int size, final boolean isSpace,
            final Set<String> termCache) {
        final String target = rightString(buf, size);
        if (!termCache.contains(target)) {
            termCache.add(target);
            return isSpace;
        }
        buf.setLength(buf.length() - size);
        if (!isSpace && !isLastSpaceChar(buf)) {

}

// Resize changes the cache size. Size of 0 means unlimited.
func (c *LRU[K, V]) Resize(size int) (evicted int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if size <= 0 {
		c.size = 0
		return 0
	}
	diff := c.evictList.Length() - size
	if diff < 0 {
		diff = 0
	}
	for i := 0; i < diff; i++ {
		c.removeOldest()
	}
	c.size = size
	return diff
}