/**
   * It's invalid to have a label longer than 63 characters. If that's requested, the encoder may
   * overflow and return null.
   */
  @Test fun overflowEncodingOversizedLabel() {
    val a1000 = "a".repeat(1000)
    val a1000MaxCodePoint = a1000 + "\udbff\udfff"
    testEncodeDecode(
      a1000MaxCodePoint,
      "xn--$a1000-nc89312g",
    )
    assertNull(
      Punycode.encode(a1000MaxCodePoint.repeat(2)),

            // Given
            long currentTime = System.currentTimeMillis();
            when(mockResource.lastModified()).thenReturn(currentTime);
            when(mockResource.lastAccess()).thenReturn(currentTime - 1000);
            when(mockResource.createTime()).thenReturn(currentTime - 2000);

            // When
            long lastModified = mockResource.lastModified();
            long lastAccess = mockResource.lastAccess();

        @Test
        @DisplayName("Should handle maximum buffer index")
        void testMaxBufferIndex() throws SMBProtocolDecodingException {
            // Given
            int bufferSize = 10000;
            byte[] buffer = new byte[bufferSize];
            int bufferIndex = bufferSize - 4;
            SMBUtil.writeInt2(4, buffer, bufferIndex);
            SMBUtil.writeInt2(0, buffer, bufferIndex + 2);

         * the entire path.
         */
        dr.pathConsumed -= 1 + server.length() + 1 + share.length();

        if (referrals != null && System.currentTimeMillis() + 10000 > referrals.expiration) {
            referrals = null;
        }
        if (referrals == null) {
            referrals = new CacheEntry(0);
        }
        referrals.map.put(key, dr);
    }

     * Test extraction with large text content.
     */
    public void test_getText_largeContent_extractsSuccessfully() {
        final StringBuilder largeContent = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            largeContent.append("Line ").append(i).append(" with some content\n");
        }
        final InputStream in = new ByteArrayInputStream(largeContent.toString().getBytes());

        assertEquals(version, artifactVersion.toString(), "check " + version + " string value");
    }

    @Test
    void testVersionParsing() {
        checkVersionParsing("1", 1, 0, 0, 0, null);
        checkVersionParsing("1.2", 1, 2, 0, 0, null);
        checkVersionParsing("1.2.3", 1, 2, 3, 0, null);
        checkVersionParsing("1.2.3-1", 1, 2, 3, 1, null);

		Mode:             0,
		Metadata:         nil,
		Parts:            nil,
		Erasure: ErasureInfo{
			Algorithm:    ReedSolomon.String(),
			DataBlocks:   4,
			ParityBlocks: 2,
			BlockSize:    10000,
			Index:        1,
			Distribution: []int{1, 2, 3, 4, 5, 6, 7, 8},
			Checksums: []ChecksumInfo{{
				PartNumber: 1,
				Algorithm:  HighwayHash256S,
				Hash:       nil,
			}},
		},

  @J2ktIncompatible
  @GwtIncompatible // blocking wait
  public void testRunIdempotency() throws Exception {
    int numThreads = 10;
    ExecutorService executor = newFixedThreadPool(numThreads);
    for (int i = 0; i < 1000; i++) {
      AtomicInteger counter = new AtomicInteger();
      TrustedListenableFutureTask<Integer> task =
          TrustedListenableFutureTask.create(
              new Callable<Integer>() {
                @Override

        int startOffset = 100;

        // Set up transaction parameters
        transaction.setMaxSetupCount((byte) 3);
        transaction.setTotalParameterCount(500);
        transaction.setTotalDataCount(1000);
        transaction.setMaxParameterCount(2048);
        transaction.setMaxDataCountForTest(4096);
        transaction.setParameterCount(250);
        transaction.setParameterOffset(150);

	if lc.Len() != 10 {
		t.Fatalf("length differs from expected")
	}
}

func TestLRUConcurrency(t *testing.T) {
	lc := lru.NewLRU[string, string](0, nil, 0)
	wg := sync.WaitGroup{}
	wg.Add(1000)
	for i := 0; i < 1000; i++ {
		go func(i int) {
			lc.Add(fmt.Sprintf("key-%d", i/10), fmt.Sprintf("val-%d", i/10))
			wg.Done()
		}(i)
	}
	wg.Wait()
	if lc.Len() != 100 {
		t.Fatalf("length differs from expected")