* otherwise.
   */
  @Throws(IOException::class)
  internal fun planWithCurrentOrInitialConnectionSpec(
    connectionSpecs: List<ConnectionSpec>,
    sslSocket: SSLSocket,
  ): ConnectPlan {
    if (connectionSpecIndex != -1) return this
    return nextConnectionSpec(connectionSpecs, sslSocket)
      ?: throw UnknownServiceException(
        "Unable to find acceptable protocols." +

    }

    private static boolean refExists(String ref) throws IOException, InterruptedException {
        ExecResult r = exec("git", "rev-parse", "--verify", ref);
        return r.exitCode == 0;
    }

    private static void run(String... cmd) throws IOException, InterruptedException {
        ExecResult r = exec(cmd);
        if (r.exitCode != 0) {
            throw new AssertionError(String.join(" ", cmd) + " failed: " + r);

     *
     * @param uri the URI to get response data for
     * @param includeContent whether to include content in the response
     * @return the response data
     * @throws CrawlingAccessException if unable to access the URI
     * @throws ChildUrlsException if the URI represents a directory with child URLs
     */
    protected ResponseData getResponseData(final String uri, final boolean includeContent) {

    @Test
    @DisplayName("Test decode throws exception when length is too short")
    void testDecodeThrowsExceptionWhenLengthTooShort() {
        byte[] buffer = new byte[28];

        // Test with len = 23 (one byte too short)
        SMBProtocolDecodingException exception = assertThrows(SMBProtocolDecodingException.class, () -> response.decode(buffer, 0, 23),
                "Should throw exception when length < 24");

    } catch (ExecutionException e) {
      throw e.getCause();
    }
  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * throws an {@code ExecutableException} and that the cause of the {@code ExecutableException} is
   * {@code expectedCause}.
   */
  public void assertException(Throwable expectedCause) throws Exception {

        @Override
        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_referent(netname, 1);

            if (netname != null) {
                _dst = _dst.deferred;
                _dst.enc_ndr_string(netname);

            }
        }

        @Override
        public void decode(NdrBuffer _src) throws NdrException {
            _src.align(4);

            }
        }
        throw new CrawlingAccessException("Invalid path: " + path);
    }

    /**
     * Retrieves response data for the specified URI.
     * @param uri the URI to retrieve data for
     * @param includeContent whether to include the actual content in the response
     * @return the response data containing metadata and optionally content

        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
    }

    /**
     * Closes this SAM domain handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);

                throw de;
            }

            final MsrpcSamrConnect2 rpc2 = new MsrpcSamrConnect2(server, access, this);
            handle.sendrecv(rpc2);
        }
    }

    /**
     * Closes this SAM policy handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {

     *
     * @param writer a writer object.
     * @param model a model object.
     * @throws IOException java.io.IOException if any.
     */
    public void write(Writer writer, Model model) throws IOException {
        try {
            delegate.write(writer, model.getDelegate());
        } catch (XMLStreamException e) {
            throw new IOException(e);
        }
    } // -- void write( Writer, Model )

    /**