writeParams.setAccessible(true);
            writeParams.invoke(cancel, dst, 0);

            Method writeBytes = SmbComNtCancel.class.getDeclaredMethod("writeBytesWireFormat", byte[].class, int.class);
            writeBytes.setAccessible(true);
            writeBytes.invoke(cancel, dst, 0);

            // Then - array should remain unchanged

            // Test metadata endpoint
            String metadataUrl = (String) buildDefaultUrlMethod.invoke(authenticator, "/sso/metadata");
            assertEquals("https://fess.example.com/sso/metadata", metadataUrl);

            // Test ACS endpoint
            String acsUrl = (String) buildDefaultUrlMethod.invoke(authenticator, "/sso/");
            assertEquals("https://fess.example.com/sso/", acsUrl);

    mmHeap.addAll(Lists.newArrayList(1, 2, 3, 4, 47, 1, 5, 3, 0));
    assertTrue("Heap is not intact initially", mmHeap.isIntact());
    assertEquals(9, mmHeap.size());
    mmHeap.remove(5);
    assertEquals(8, mmHeap.size());
    assertTrue("Heap is not intact after remove()", mmHeap.isIntact());
    assertEquals(47, (int) mmHeap.pollLast());
    assertEquals(4, (int) mmHeap.pollLast());

    mmHeap.addAll(Lists.newArrayList(1, 2, 3, 4, 47, 1, 5, 3, 0));
    assertTrue("Heap is not intact initially", mmHeap.isIntact());
    assertEquals(9, mmHeap.size());
    mmHeap.remove(5);
    assertEquals(8, mmHeap.size());
    assertTrue("Heap is not intact after remove()", mmHeap.isIntact());
    assertEquals(47, (int) mmHeap.pollLast());
    assertEquals(4, (int) mmHeap.pollLast());

        String result = (String) method.invoke(keyMatchHelper, "JAVA");
        assertEquals("java", result);

        result = (String) method.invoke(keyMatchHelper, "Mixed_Case");
        assertEquals("mixed_case", result);

        result = (String) method.invoke(keyMatchHelper, (String) null);
        assertNull(result);

        result = (String) method.invoke(keyMatchHelper, "");
        assertEquals("", result);

        setTreeIdMethod.setAccessible(true);
        setTreeIdMethod.invoke(response, -1);
        assertFalse(response.isValidTid());

        // Test valid TID
        setTreeIdMethod.invoke(response, 100);
        assertTrue(response.isValidTid());

        // Test zero TID (valid)
        setTreeIdMethod.invoke(response, 0);
        assertTrue(response.isValidTid());
    }

    @Test

        processMethod.setAccessible(true);

        try {
            Integer result = (Integer) processMethod.invoke(null, options);
            assertNotNull(result);
            assertEquals(1, result.intValue());
        } catch (Exception e) {
            // Expected behavior when components are not fully initialized

            assertEquals("0", getResultMessageMethod.invoke(null, 0), "Should return '0' for success");
            assertEquals("DCERPC_BIND_ERR_ABSTRACT_SYNTAX_NOT_SUPPORTED", getResultMessageMethod.invoke(null, 1),
                    "Should return correct message for error 1");
            assertEquals("DCERPC_BIND_ERR_PROPOSED_TRANSFER_SYNTAXES_NOT_SUPPORTED", getResultMessageMethod.invoke(null, 2),

    Prepender prepender = delegate.invoke(null, "a", 1);
    assertThat(prepender.prefix).isEqualTo("a");
    assertEquals(1, prepender.times);
  }

  public void testConstructor_returning() throws Exception {
    Invokable<?, Prepender> delegate =
        Prepender.constructor(String.class, int.class).returning(Prepender.class);
    Prepender prepender = delegate.invoke(null, "a", 1);

        fun Int.fooExt() {}

        val String.barExt: String
            get() = "bar"

        var Int.bazarExt: String
            get() = "bar"
            set(value) = Unit

        operator fun String.invoke(p: String, block: String.() -> Unit) = Unit