* @param response
     * @param params
     * @throws IOException
     * @throws SmbException
     * @throws TransportException
     * @throws EOFException
     */
    private <T extends CommonServerMessageBlock & Response> T sendComTransaction(final CommonServerMessageBlockRequest request,
            final T response, final Set<RequestParam> params) throws IOException, SmbException, TransportException, EOFException {

     *
     * @throws IOException thrown by {@code SmbFileInputStream} constructor
     */
    @Override
    public InputStream getInputStream() throws IOException {
        return new SmbFileInputStream(this);
    }

    /**
     * This URLConnection method just returns a new {@code SmbFileOutputStream} created with this file.
     *

     * @return A byte array representing the ticket
     * @throws IOException on encoding error
     */
    private byte[] createTestTicketBytes(Number version, String realm, String principalName, int encType, byte[] encryptedData,
            Integer unknownTag) throws IOException {
        ASN1EncodableVector v = new ASN1EncodableVector();

            } ?: return
          }
        } catch (thrown: Throwable) {
          // A task failed. Update execution state and re-throw the exception.
          withLock {
            afterRun(task, -1L, false)
          }
          if (thrown is InterruptedException) {
            Thread.currentThread().interrupt()
          } else {
            throw thrown
          }
        } finally {

      invalidate(key);
    }
  }

  @Override
  public void invalidateAll() {
    throw new UnsupportedOperationException();
  }

  @Override
  public CacheStats stats() {
    throw new UnsupportedOperationException();
  }

  @Override
  public ConcurrentMap<K, V> asMap() {
    throw new UnsupportedOperationException();
  }

  /**

     * Invalid archives may either throw an exception or return empty content.
     */
    public void test_TarExtractor_invalidArchive_handlesGracefully() {
        final InputStream invalidStream = new ByteArrayInputStream("not a valid tar file".getBytes());

        try {
            final ExtractData result = tarExtractor.getText(invalidStream, null);
            // If no exception is thrown, result should be empty or minimal

        } catch (Exception e) {
            fail("Should not throw exception in test setup");
        }

        // Execute and verify ChildUrlsException is thrown
        try {
            processor.process(responseData);
            fail("Should throw ChildUrlsException");
        } catch (ChildUrlsException e) {
            // Expected exception

    }

    @Override
    public void reset() throws IOException {
        // In real implementation, this would reset the DiSNI connection
        connect();
    }

    @Override
    public int read(ByteBuffer buffer, long remoteAddress, int remoteKey, int length) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED) {
            throw new IOException("Connection not established");
        }

            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            throw new RuntimeException("Failed to get field value: " + fieldName, e);
        }
    }

    private void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
        Field field = getField(obj.getClass(), fieldName);
        field.setAccessible(true);
        field.set(obj, value);

        this.bytesReceived += byteCount
      } catch (e: IOException) {
        throw complete(e)!!
      }
    }

    @Throws(IOException::class)
    override fun flush() {
      try {
        super.flush()
      } catch (e: IOException) {
        throw complete(e)!!
      }
    }

    @Throws(IOException::class)
    override fun close() {
      if (closed) return
      closed = true