protected void doStart() {
            super.doStart();
            // This will delay service listener execution at least 150 milliseconds
            Uninterruptibles.sleepUninterruptibly(150, MILLISECONDS);
          }
        };
    Service a =
        new NoOpDelayedService(150) {
          @Override
          protected void doStart() {
            b.startAsync();
            super.doStart();
          }

          protected void doStart() {
            super.doStart();
            // This will delay service listener execution at least 150 milliseconds
            Uninterruptibles.sleepUninterruptibly(150, MILLISECONDS);
          }
        };
    Service a =
        new NoOpDelayedService(150) {
          @Override
          protected void doStart() {
            b.startAsync();
            super.doStart();
          }

    val delays = mutableListOf(50.µs, 150.µs, -1L)
    redQueue.schedule("task", 100.µs) {
      log += "run@${taskFaker.nanoTime}"
      return@schedule delays.removeAt(0)
    }

    taskFaker.advanceUntil(0.µs)
    assertThat(log).containsExactly()

    taskFaker.advanceUntil(100.µs)
    assertThat(log).containsExactly("run@100000")

    taskFaker.advanceUntil(150.µs)

        // Open the circuit
        circuitBreaker.tripBreaker();
        assertEquals(SimpleCircuitBreaker.State.OPEN, circuitBreaker.getState());

        // Wait for timeout
        Thread.sleep(150);

        // Next call should transition to HALF_OPEN
        String result = circuitBreaker.call(() -> "success");
        assertEquals("success", result);

            }

            @Override
            public int getLtrWindowSize() {
                return 150;
            }
        });

        RescorerBuilder<?> result3 = ltrQueryRescorer.evaluate(params);
        assertNotNull(result3);
        assertEquals(150, ((QueryRescorerBuilder) result3).windowSize().intValue());
    }

        transaction.setMaxParameterCount(1024);
        transaction.setMaxDataCountForTest(2048);
        transaction.setParameterCount(50);
        transaction.setParameterOffset(80);
        transaction.setDataCount(150);
        transaction.setDataOffset(130);
        transaction.setSetupCount(1);
        transaction.setSetupWireFormatReturn(4);

        // Execute the method

        void flagsInDifferentOrder() {
            TestLocking t = new TestLocking();

            // Parse flags in different order
            String[] args = { "smb://test/file.txt", "-i", "4", "-t", "2", "-d", "150" };
            for (int ai = 0; ai < args.length; ai++) {
                if (args[ai].equals("-t")) {
                    ai++;
                    t.numThreads = Integer.parseInt(args[ai]);

        @DisplayName("Should handle encode-decode round-trip correctly")
        void testEncodeDecodeRoundTrip() throws NdrException {
            // Given: Original value that fits in byte range
            int originalValue = 150;
            NdrShort ndrShort1 = new NdrShort(originalValue);

            // Create separate mocks for encoding and decoding to simulate real buffer
            NdrBuffer encodeBuffer = mock(NdrBuffer.class);

Harshavardhana <******@****.***> 1744208919 -0700

        SMBUtil.writeInt4(80, buffer, bufferIndex + 15);

        // parameterDisplacement (4 bytes)
        SMBUtil.writeInt4(10, buffer, bufferIndex + 19);

        // dataCount (4 bytes)
        SMBUtil.writeInt4(150, buffer, bufferIndex + 23);

        // dataOffset (4 bytes)
        SMBUtil.writeInt4(160, buffer, bufferIndex + 27);

        // dataDisplacement (4 bytes)
        SMBUtil.writeInt4(20, buffer, bufferIndex + 31);