// Blocks will read this much and find the first following newline.
// 128KB appears to be a very reasonable default.
const jsonSplitSize = 128 << 10

// startReaders will read the header if needed and spin up a parser
// and a number of workers based on GOMAXPROCS.
// If an error is returned no goroutines have been started and r.err will have been set.
func (r *PReader) startReaders() {

    }

    @Test
    @DisplayName("Test decode with larger buffer and length")
    void testDecodeWithLargerBufferAndLength() throws SMBProtocolDecodingException {
        // Test with buffer and length larger than needed
        byte[] buffer = new byte[100];

        // Fill test pattern
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) (i % 256);
        }

        pdis.readByte(); // position is 1
        pdis.align(4);
        assertEquals(1, pdis.available());
        assertEquals(0x05, pdis.readByte());

        // Test no alignment needed
        pdis = createInputStream(new byte[] { 0x01, 0x02, 0x03, 0x04 });
        pdis.readInt(); // position is 4
        pdis.align(4);
        assertEquals(0, pdis.available());

        // Test alignment with mask 0

    if (length == 0) {
      return of();
    }
    return new RegularImmutableList<E>(elements, length);
  }

  ImmutableList() {}

  // This declaration is needed to make List.iterator() and
  // ImmutableCollection.iterator() consistent.
  @Override
  public UnmodifiableIterator<E> iterator() {
    return listIterator();
  }

  @Override

    private SmbTree smbTree;

    @Mock
    private SmbTree mockWrappedTree;

    /**
     * Setup method executed before each test.
     */
    @BeforeEach
    void setUp() {
        // Common setup if needed
    }

    /**
     * Test for unwrap() method with matching type.
     * Verifies that unwrap returns the correct instance when the type matches.
     */
    @Test
    void testUnwrap_withMatchingType() {

        }
        return url.toString();
    }

    /**
     * Builds a URL from protocol, hostname string, port, and path.
     * Properly handles IPv6 addresses by wrapping them in brackets if needed.
     *
     * @param protocol the protocol (e.g., "http", "https")
     * @param host the hostname or IP address string
     * @param port the port number
     * @param path the path (should start with "/" or be empty)

        this.lifecycleDebugLogger = lifecycleDebugLogger;
        this.lifeCycleExecutionPlanCalculator = lifeCycleExecutionPlanCalculator;
        this.eventCatapult = eventCatapult;
    }

    /**
     * Ctor needed for UT.
     */
    BuilderCommon(
            LifecycleDebugLogger lifecycleDebugLogger,
            LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator,
            ExecutionEventCatapult eventCatapult,

        @Test
        @DisplayName("Should handle response at end of buffer")
        void testResponseAtEndOfBuffer() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[20]; // Exact size needed
            SMBUtil.writeInt2(17, buffer, 0);
            SMBUtil.writeInt2(0, buffer, 2);
            SMBUtil.writeInt4(999, buffer, 4);
            SMBUtil.writeInt4(111, buffer, 8);

            when(mockCtx.supportsIntegrity()).thenReturn(true);
            when(mockCtx.calculateMIC(any(byte[].class))).thenReturn(new byte[] { 42 });
            // verifyMIC returns void; no stubbing needed
            when(mockCtx.isMICAvailable()).thenReturn(true);

            // Act
            useContext(mockCtx);

            // Assert: verify key interactions and ordering where meaningful

/**
 * Unit test for {@link Joiner}.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
public class JoinerTest extends TestCase {
  private static final Joiner J = Joiner.on("-");

  // <Integer> needed to prevent warning :(
  private static final Iterable<Integer> iterable = Arrays.<Integer>asList();
  private static final Iterable<Integer> iterable1 = Arrays.asList(1);