@Test
    void testJdk7ipv6() {
        ConnectException connEx = new ConnectException("Connection refused: connect");
        IOException ioEx = new IOException("Unable to establish loopback connection", connEx);
        MojoExecutionException mojoEx =
                new MojoExecutionException("Error executing Jetty: Unable to establish loopback connection", ioEx);

        ExceptionHandler exceptionHandler = new DefaultExceptionHandler();

        System.out.println();
        System.out.println("Parent SCM connection is: " + project0.getScm().getConnection());
        System.out.println("Child SCM connection is: " + project1.getScm().getConnection());
        System.out.println();
        System.out.println(
                "Parent SCM developer connection is: " + project0.getScm().getDeveloperConnection());
        System.out.println(

        Protocol protocol, IOException ioe) {
      printEvent("connectFailed");
    }

    @Override public void connectionAcquired(Call call, Connection connection) {
      printEvent("connectionAcquired");
    }

    @Override public void connectionReleased(Call call, Connection connection) {
      printEvent("connectionReleased");
    }

    @Override public void requestHeadersStart(Call call) {

    boolean hasCapability ( int cap ) throws CIFSException;


    /**
     * @return the send buffer size of the underlying connection
     * @throws CIFSException
     */
    int getSendBufferSize () throws CIFSException;


    /**
     * @return the receive buffer size of the underlying connection
     * @throws CIFSException
     */
    int getReceiveBufferSize () throws CIFSException;


    /**

        }
    }

    /* Build a connection. Only one thread will ever call this method at
     * any one time. If this method throws an exception or the connect timeout
     * expires an encapsulating TransportException will be thrown from connect
     * and the transport will be in error.
     */

    protected abstract void doConnect() throws Exception;

    /* Tear down a connection. If the hard parameter is true, the diconnection

     */
    boolean isTrustedDomain ( CIFSContext tf, String domain ) throws CIFSException;


    /**
     * Get a connection to the domain controller for a given domain
     * 
     * @param domain
     * @param tf
     * @return connection
     * @throws CIFSException
     * @throws jcifs.smb.SmbAuthException
     */
    SmbTransport getDc ( CIFSContext tf, String domain ) throws CIFSException;

        Protocol protocol, IOException ioe) {
      printEvent("connectFailed");
    }

    @Override public void connectionAcquired(Call call, Connection connection) {
      printEvent("connectionAcquired");
    }

    @Override public void connectionReleased(Call call, Connection connection) {
      printEvent("connectionReleased");
    }

    @Override public void requestHeadersStart(Call call) {

    private SmbNamedPipe pipe;
    private int head;

    static final int STATUS_DISCONNECTED = 1;
    static final int STATUS_LISTENING = 2;
    static final int STATUS_CONNECTION_OK = 3;
    static final int STATUS_SERVER_END_CLOSED = 4;

    int status, available;

    TransPeekNamedPipeResponse( SmbNamedPipe pipe ) {
        this.pipe = pipe;
    }

    /**
     * Get transport connection
     * 
     * @param tc
     *            context to use
     * @param address
     * @param port
     * @param exclusive
     *            whether to acquire an unshared connection
     * @param forceSigning
     *            whether to enforce SMB signing on this connection
     * @return a transport connection to the target
     */

                }
                break;
            case ERR_SSN_SRVC:
                result += "ERR_SSN_SRVC/";
                switch( errorCode ) {
                    case CONNECTION_REFUSED:
                        result += "Connection refused";
                        break;
                    case NOT_LISTENING_CALLED:
                        result += "Not listening on called name";
                        break;