SmbOperationException.RetryPolicy defaultPolicy = SmbOperationException.RetryPolicy.DEFAULT;
        assertEquals(3, defaultPolicy.getMaxAttempts());
        assertEquals(1000, defaultPolicy.getInitialDelayMs());
        assertEquals(30000, defaultPolicy.getMaxDelayMs());
        assertEquals(2.0, defaultPolicy.getBackoffMultiplier());
        assertTrue(defaultPolicy.isExponentialBackoff());

        // AGGRESSIVE policy

00000c0 88 21 c4 00 00 14 00 eb ff 42 88 21 c4 00 00 14
00000d0 00 eb ff 42 88 21 c4 00 00 14 00 eb ff 42 88 21
00000e0 c4 00 00 00 00 ff ff 00 00 00 ff ff 00 34 00 cb
00000f0 ff 42 88 21 c4 00 00 00 00 ff ff 00 00 00 ff ff
0000100 00 34 00 cb ff 42 e8 21 5e 0f 00 00 00 ff ff 0a
0000110 f0 66 64 12 61 c0 15 dc e8 a0 48 bf 48 af 2a b3
0000120 20 c0 9b 95 0d c4 67 04 42 53 06 06 06 40 00 06

                                        <input type="number" name="depth" id="depth"
                                               value="${f:h(depth)}" class="form-control"
                                               min="0" max="10000">
                                    </div>
                                </div>
                                <div class="form-group row">

    }

    @Test
    public void test_GetContentAsString_LargeContent() {
        // ## Arrange ##
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            sb.append("Line ").append(i).append(": This is a test line with some content.\n");
        }
        String content = sb.toString();
        CurlResponse response = new CurlResponse();

    }
    suite.addTestSuite(ByteSourceTest.class);
    return suite;
  }

  private static final byte[] bytes = newPreFilledByteArray(10000);

  private TestByteSource source;

  @Override
  protected void setUp() throws Exception {
    source = new TestByteSource(bytes);
  }

  public void testOpenBufferedStream() throws IOException {

      assertThat(expected)
          .hasMessageThat()
          .isEqualTo("Unpaired surrogate at index " + invalidCodePointIndex);
    }
  }

  // 128 - [chars 0x0000 to 0x007f]
  private static final long ONE_BYTE_ROUNDTRIPPABLE_CHARACTERS = 0x007f - 0x0000 + 1;

  // 128
  private static final long EXPECTED_ONE_BYTE_ROUNDTRIPPABLE_COUNT =
      ONE_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  // 1920 [chars 0x0080 to 0x07FF]

    executor.execute(new SleepTask(10000));
    executor.shutdown();
    assertFalse(awaitTerminationUninterruptibly(executor, 1000, MILLISECONDS));
    assertFalse(executor.isTerminated());
    assertInterrupted();
  }

  public void testTryAwaitTerminationInfiniteTimeout() {
    ExecutorService executor = newFixedThreadPool(1);
    requestInterruptIn(500);
    executor.execute(new SleepTask(1000));
    executor.shutdown();

		}
	}
}

func BenchmarkGetPartFileWithTrie(b *testing.B) {
	b.ResetTimer()

	entriesTrie := trie.NewTrie()
	for i := 1; i <= 10000; i++ {
		entriesTrie.Insert(fmt.Sprintf("%.5d.8a034f82cb9cb31140d87d3ce2a9ede3.67108864", i))
	}

	for i := 1; i <= 10000; i++ {
		partFile := getPartFile(entriesTrie, i, "8a034f82cb9cb31140d87d3ce2a9ede3")
		if partFile == "" {
			b.Fatal("partFile returned is empty")
		}

        }

        @Test
        @DisplayName("Should decode efficiently for large buffers")
        void testLargeBufferDecoding() throws SMBProtocolDecodingException {
            byte[] largeBuffer = new byte[10000];
            FileFsSizeInformation info = new FileFsSizeInformation();

            long startTime = System.nanoTime();
            info.decode(largeBuffer, 0, 24);
            long endTime = System.nanoTime();

        if (timeoutMs == 0) {
            return 0L; // Persistent handles use 0
        }
        // Convert milliseconds to 100-nanosecond intervals
        // 1 ms = 10,000 * 100ns intervals
        long intervals = timeoutMs * 10000L;
        // MS-SMB2 timeout field is 4 bytes (uint32), so clamp to max value
        return Math.min(intervals, 0xFFFFFFFFL);
    }

    /**
     * Get the flags