}

  public void testFromByteArray_withTooLongArrayInputThrowsIllegalArgumentException() {
    byte[] buffer = MANY_VALUES_PAIRED_STATS.toByteArray();
    byte[] tooLongByteArray =
        ByteBuffer.allocate(buffer.length + 2)
            .order(ByteOrder.LITTLE_ENDIAN)
            .put(buffer)
            .putChar('.')
            .array();

class PacSignatureTest {

    /**
     * Helper method to write integer in little-endian format.
     */
    private void writeLittleEndianInt(ByteArrayOutputStream baos, int value) {
        ByteBuffer buffer = ByteBuffer.allocate(4);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putInt(value);
        baos.write(buffer.array(), 0, 4);
    }

    /**
     * Test constructor with KERB_CHECKSUM_HMAC_MD5 type.
     *

        assertSame(c, second, "Second get should return second cached buffer");
        assertNotSame(d, third, "Third get should allocate a new buffer (not the dropped one)");
        assertEquals(3, third.length, "Allocated buffer length matches configured maximum size");
    }

    // Parameterized: exercise small variations of cache size for a simple reuse cycle
    @ParameterizedTest

            assertTrue(initialAllocated >= 2, "Should have allocated at least 2 regions");
            assertTrue(initialActive >= 2, "Should have at least 2 active regions");

            // Test buffer release and reuse
            bufferManager.releaseSendRegion(sendRegion);
            bufferManager.releaseReceiveRegion(recvRegion);

            // Allocate again to test pooling

     * {@link NtTransQuerySecurityDesc#writeParametersWireFormat(byte[], int)}.
     */
    private static byte[] expectedParameters(int fid, int securityInformation) {
        ByteBuffer bb = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
        bb.putShort((short) fid);
        bb.put((byte) 0x00); // Reserved
        bb.put((byte) 0x00); // Reserved
        bb.putInt(securityInformation);
        return bb.array();

    }

    @Test
    void emptySha1Calculator() {
        ChecksumAlgorithmService.ChecksumCalculator calculator =
                service.select("SHA-1").getCalculator();
        calculator.update(ByteBuffer.allocate(0));
        assertEquals("da39a3ee5e6b4b0d3255bfef95601890afd80709", calculator.checksum());
    }

    @Test
    void calculateByte() throws IOException {

import java.util.Random;
import org.jspecify.annotations.NullUnmarked;

/**
 * Benchmarks for various potential implementations of {@code ByteSource.asCharSource(...).read()}.
 */
// These benchmarks allocate a lot of data so use a large heap
@VmOptions({"-Xms12g", "-Xmx12g", "-d64"})
@NullUnmarked
public class ByteSourceAsCharSourceReadBenchmark {
  enum ReadStrategy {
    TO_BYTE_ARRAY_NEW_STRING {
      @Override

    allocateAndLeakAllocation(poolApi, c1)
    awaitGarbageCollection()
    assertThat(pool.closeConnections(100L)).isEqualTo(0L)
    assertThat(c1.calls).isEmpty()

    // Can't allocate once a leak has been detected.
    assertThat(c1.noNewExchanges).isTrue()
  }

  @Test fun interruptStopsThread() {
    val taskRunnerThreads = mutableListOf<Thread>()
    val taskRunner =
      TaskRunner(

    when {
      logger.isLoggable(Level.FINE) -> Throwable(closer) // These are expensive to allocate.
      else -> null
    }

  open fun logCloseableLeak(
    message: String,
    stackTrace: Any?,
  ) {
    var logMessage = message
    if (stackTrace == null) {
      logMessage += " To see where this was allocated, set the OkHttpClient logger level to " +

						kvs = jstream.KVS{jstream.KV{Key: "_1", Value: mv.Value}}
					}
					all = append(all, kvs)
				}
				// We don't need the input any more.
				//nolint:staticcheck // SA6002 Using pointer would allocate more since we would have to copy slice header before taking a pointer.
				r.bufferPool.Put(in.input)
				in.input = nil
				in.err = d.Err()
				in.dst <- all
			}
		}()
	}
}