assertEquals(HashSet(expectedPins), certificatePinner.pins)
  }

  companion object {
    val certA1 =
      HeldCertificate
        .Builder()
        .serialNumber(100L)
        .build()
    val certA1Sha256Pin = pin(certA1.certificate)
    val certB1 =
      HeldCertificate
        .Builder()
        .serialNumber(200L)
        .build()

	if ioStats.WriteIOs > 0 {
		m.writesAwait = float64(ioStats.WriteTicks) / float64(ioStats.WriteIOs)
	}

	// TotalTicks is in milliseconds
	m.percUtil = float64(ioStats.TotalTicks) * 100 / (durationSecs * 1000)

	return m
}

func newDriveMetricsCache() *cachevalue.Cache[storageMetrics] {
	var (
		// prevDriveIOStats is used to calculate "per second"

     * @return the extracted body text
     * @throws ExtractException if extraction fails
     */
    protected String getBodyText(final MimeMessage message) {
        final StringBuilder buf = new StringBuilder(1000);
        try {
            final Object content = message.getContent();
            if (content instanceof final Multipart multipart) {
                final int count = multipart.getCount();

        mockConfig = mock(Configuration.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        when(mockConfig.getLeaseTimeout()).thenReturn(30000);
        when(mockConfig.getMaxLeases()).thenReturn(1000);
        when(mockConfig.getLeaseBreakTimeout()).thenReturn(60);
        leaseManager = new LeaseManager(mockContext);
    }

    @AfterEach
    void tearDown() {
        if (leaseManager != null) {

            w.write(payload, payload.length, out);

            // Give the writer thread time to process and set exception
            w.wait(100);
        }

        // Wait a bit more to ensure exception is captured
        Thread.sleep(100);

        // Act + Assert: checkException should throw the SmbException captured by the thread
        assertThrows(SmbException.class, w::checkException);

                                               value="${f:h(numOfThread)}" class="form-control"
                                               min="1" max="1000">
                                    </div>
                                </div>
                                <div class="form-group row">

        private final Map<String, Object> dataMap = new HashMap<>();

        private String fieldName;

        private final StringBuilder buffer = new StringBuilder(1000);

        @Override
        public void startDocument() {
            dataMap.clear();
        }

        @Override

        assertEquals(1, validator.safeMultiply(1, 1));

        // Test exact buffer boundaries
        byte[] buffer = new byte[100];
        validator.validateBufferAccess(buffer, 0, 100); // Exactly full buffer
        validator.validateBufferAccess(buffer, 100, 0); // Zero length at end
    }

        byte[] buffer = new byte[2048];
        int bufferIndex = 100;

        // Set structure size to 9
        SMBUtil.writeInt2(9, buffer, bufferIndex);
        // Set large buffer offset
        SMBUtil.writeInt2(1000, buffer, bufferIndex + 2);
        // Set buffer length
        SMBUtil.writeInt4(8, buffer, bufferIndex + 4);

        final Extractor extractor = getExtractor(responseData);
        final String mimeType = responseData.getMimeType();
        final StringBuilder contentMetaBuf = new StringBuilder(1000);
        final Map<String, Object> dataMap = new HashMap<>();
        final Map<String, Object> metaDataMap = new HashMap<>();
        String content;
        try (final InputStream in = responseData.getResponseBody()) {