throws MalformedURLException, DcerpcException {
        return DcerpcHandle.getHandle(String.format("ncacn_np:%s[endpoint=%s,address=%s]", loc.getServer(), ep, address.getHostAddress()),
                ctx);
    }

 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file
 * with desired access bits <code>0x00000003</code> (<code>FILE_READ_DATA |
 * FILE_WRITE_DATA</code>) and the target file has the following security
 * descriptor ACEs:
 * <pre>
 * Allow WNET\alice     0x001200A9  Direct
 * Allow Administrators 0x001F01FF  Inherited
 * Allow SYSTEM         0x001F01FF  Inherited
 * </pre>

     */
    @Test
    public void readParameterWordsWireFormat_parsesHeaderCorrectly() {
        DummyResponse d = new DummyResponse();
        // Construct a minimal wire format buffer
        byte[] buf = new byte[32];
        int idx = 0;
        // Write values little-endian
        buf[idx++] = 5; // totalParameterCount low byte

    CheckSetUpInvocationHandler(Map<String, String> map, AtomicBoolean setUpRan) {
      this.map = map;
      this.setUpRan = setUpRan;
    }

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {

    throw new UnsupportedOperationException();
  }

  /**
   * {@inheritDoc}
   *
   * <p>This implementation of {@code getAllPresent} lacks any insight into the internal cache data
   * structure, and is thus forced to return the query keys instead of the cached keys. This is only
   * possible with an unsafe cast which requires {@code keys} to actually be of type {@code K}.
   *
   * @since 11.0
   */
  /*

     */
    protected String getResourcePath(final String basePath, final String type, final String path) {
        final String target = basePath + "/_" + type + path;
        if (ResourceUtil.getResourceNoException(target) != null) {
            return target;
        }
        return basePath + path;
    }

    /**
     * Adds field mappings to an index.
     *

        case FILE_MODIFIED:
            // Remove from cache to force refresh
            entry.removeChild(childName);
            break;

        case DIRECTORY_RENAMED:
            // Full invalidation needed
            entry.invalidate();
            break;

        case ATTRIBUTES_CHANGED:
            // Remove from cache to force refresh
            entry.removeChild(childName);
            break;

        assertEquals(expectedTime, response.getLastAccessTime());
    }

    @Test
    void testReadParameterWordsWireFormatWithData() {
        // Test reading parameter words from wire format
        response = new SmbComQueryInformationResponse(mockConfig, 0L);

        // Prepare test data
        byte[] buffer = new byte[256];
        int bufferIndex = 0;

        // Set wordCount to non-zero

        assertTrue(result.contains("action="));
        assertTrue(result.contains("file=" + fileName));
        // Hexdump.toHexString produces 4-character padded uppercase hex
        String expectedHex = String.format("%04X", action);
        assertTrue(result.contains("0x" + expectedHex));
    }

    @Test
    @DisplayName("Test toString with empty object")
    void testToStringEmpty() {

            int result = (int) method.invoke(cancel, buffer, bufferIndex);

            // Then
            assertEquals(0, result);
        }
    }

    @Nested
    @DisplayName("Wire Format Tests")
    class WireFormatTests {

        private SmbComNtCancel cancel;
        private Configuration mockConfig;

        @BeforeEach
        void setUp() throws Exception {