*
   * @param permitsPerSecond the rate of the returned {@code RateLimiter}, measured in how many
   *     permits become available per second
   * @throws IllegalArgumentException if {@code permitsPerSecond} is negative or zero
   */
  // TODO(user): "This is equivalent to
  // {@code createWithCapacity(permitsPerSecond, 1, TimeUnit.SECONDS)}".

    @Mock
    private CIFSContext mockContext;

    @Mock
    private Configuration mockConfig;

    private MockWitnessService mockService;

    @BeforeEach
    void setUp() throws Exception {
        mockService = new MockWitnessService();
        mockService.start();

        // Setup mock configuration with lenient stubbing
        lenient().when(mockContext.getConfig()).thenReturn(mockConfig);

    @BeforeEach
    void setUp() {
        transactionMock = mock(SmbComTransactionResponse.class);
    }

    @Test
    void testSmbComQueryInformationResponseGetters() throws Exception {
        // The constructor is package‑private; use an anonymous subclass
        SmbComQueryInformationResponse resp = new SmbComQueryInformationResponse(1000L) {
        };

   * return the value but instead throw an exception.
   */
  private var trailers: Headers? = null

  override val isResponseComplete: Boolean
    get() = state == STATE_CLOSED

  override fun createRequestBody(
    request: Request,
    contentLength: Long,
  ): Sink =
    when {
      request.body?.isDuplex() == true -> {
        throw ProtocolException(

     *
     * @param resource the SMB resource to test
     * @return whether the given resource should be included
     * @throws CIFSException if an error occurs while accessing the resource
     */
    boolean accept(SmbResource resource) throws CIFSException;

    // something else.
    TimeZone.setDefault(TimeZone.getTimeZone("America/Los_Angeles"))
  }

  @AfterEach
  @Throws(Exception::class)
  fun tearDown() {
    TimeZone.setDefault(originalDefault)
  }

  @Test
  @Throws(Exception::class)
  fun parseStandardFormats() {
    // RFC 822, updated by RFC 1123 with GMT.

            encodeCallCount++;
            if (throwOnEncode) {
                throw new RuntimeException("Test encode error");
            }
            if (dst == null) {
                throw new IllegalArgumentException("Destination buffer cannot be null");
            }
            if (dstIndex < 0) {
                throw new IllegalArgumentException("Destination index cannot be negative");
            }

        try (FileWriter indexFileWriter = new FileWriter(indexFile)) {
            indexFileWriter.write(generateFile(versions, Files.readString(indexTemplate.toPath())));
        }
    }

    @VisibleForTesting
    static String generateFile(Set<QualifiedVersion> versionsSet, String template) throws IOException {

   * strict, use {@link #reserialize}.
   *
   * @return the re-serialized object
   * @throws RuntimeException if the specified object was not successfully serialized or
   *     deserialized
   * @throws AssertionFailedError if the re-serialized object is not equal to the original object,
   *     or if the hashcodes are different.
   */
  @CanIgnoreReturnValue

    assertThrows(
        IllegalArgumentException.class, () -> ticker.setAutoIncrementStep(-1, NANOSECONDS));
  }

  @GwtIncompatible // concurrency

  public void testConcurrentAdvance() throws Exception {
    FakeTicker ticker = new FakeTicker();

    int numberOfThreads = 64;
    runConcurrentTest(
        numberOfThreads,
        () -> {
          // adds two nanoseconds to the ticker