// Multiple leading backslashes - only first one gets stripped, then trailing ones get stripped
        // But getPath() adds a backslash at the beginning, so \\fourth\path\\ becomes \fourth\path\
        request.setPath("\\\\fourth\\path\\\\");
        assertEquals("\\\\fourth\\path\\", request.getPath());
    }

        CommonServerMessageBlockRequest fourth = third.getNext();
        boolean firstAllowsSecond = request.allowChain(nextRequest);
        boolean secondAllowsThird = nextRequest.allowChain(thirdRequest);

        // Then
        assertEquals(nextRequest, second);
        assertEquals(thirdRequest, third);
        assertNull(fourth);
        assertTrue(firstAllowsSecond);

        assertEquals(0, dst[1], "Second byte should be 0");
        assertEquals(0, dst[2], "Third byte should be 0 (no FID)");
        assertEquals(0, dst[3], "Fourth byte should be 0 (no FID)");
    }

    @Test
    public void testReadSetupWireFormat() {
        // Test the readSetupWireFormat method
        TransWaitNamedPipe pipe = new TransWaitNamedPipe("\\\\pipe\\testPipe");

        assertNotNull(queryRescorer.evaluate(params)); // Second call - even
        assertNull(queryRescorer.evaluate(params)); // Third call - odd
        assertNotNull(queryRescorer.evaluate(params)); // Fourth call - even
    }

    /**
     * Creates a mock RescorerBuilder for testing purposes.
     * Uses QueryRescorerBuilder with a simple query.
     */
    private RescorerBuilder<?> createMockRescorerBuilder() {

        assertTrue(aggregateLogJob.execute().contains("Invalid argument"));

        // Third execution - IllegalStateException
        assertTrue(aggregateLogJob.execute().contains("Invalid state"));

        // Fourth execution - NullPointerException
        assertTrue(aggregateLogJob.execute().contains("Null pointer"));

        // Fifth execution - RuntimeException
        assertTrue(aggregateLogJob.execute().contains("Generic error"));

            || (((byte1 << 28) + (byte2 - (byte) 0x90)) >> 30) != 0
            // Third byte trailing-byte test
            || bytes[index++] > (byte) 0xBF
            // Fourth byte trailing-byte test
            || bytes[index++] > (byte) 0xBF) {
          return false;
        }
      }
    }
  }

  private static String unpairedSurrogateMsg(int i) {

        // First: "" (sb becomes "")
        // Second: sb.length() is 0, no delimiter, append null (sb becomes "null")
        // Third: sb.length() > 0, add "-" + "value" (sb becomes "null-value")
        // Fourth: sb.length() > 0, add "-" + "" (sb becomes "null-value-")
        // Fifth: sb.length() > 0, add "-" + null (sb becomes "null-value--null")
        assertEquals("null-value--null", result);
    }

    @Test

  private abstract static class Third<T, D> extends Second<T> {}

  private abstract static class Fourth<T, D> extends Third<D, T> {}

  private static class ConcreteIntegerString extends Fourth<Integer, String> {}

  private static class ConcreteStringInteger extends Fourth<String, Integer> {}

  public void testAssignableClassToClass() {
    @SuppressWarnings("rawtypes") // To test TypeToken<List>

  private abstract static class Third<T, D> extends Second<T> {}

  private abstract static class Fourth<T, D> extends Third<D, T> {}

  private static class ConcreteIntegerString extends Fourth<Integer, String> {}

  private static class ConcreteStringInteger extends Fourth<String, Integer> {}

  public void testAssignableClassToClass() {
    @SuppressWarnings("rawtypes") // To test TypeToken<List>

            contexts[1] = null; // Null context
            contexts[2] = new MockCreateContextRequest("THIRD");
            contexts[3] = new MockCreateContextRequest("FOURTH");

            byte[] buffer = new byte[256];
            int offset = 0;
            int validCount = 0;

            for (CreateContextRequest context : contexts) {
                if (context != null) {