* and providing a <code>message</code>.
     *
     * @param message
     * @param cause
     * @since 2.0.9
     */
    public MojoFailureException(String message, Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new {@code MojoFailureException} exception wrapping an underlying {@code Throwable}.
     *

                                .attribute("id", "label-for-line-wrapping-toggle")
                                .attribute("for", "line-wrapping-toggle")
                                .characters("Wrap lines")
                                .startElement("input")
                                    .attribute("id", "line-wrapping-toggle")
                                    .attribute("type", "checkbox")

        // layout weirdness
        int maxWidth;
        int cols = consoleMetaData.getCols();
        if (cols > 0) {
            maxWidth = cols - 1;
        } else {
            // Assume 80 wide. This is to minimize wrapping on console where we don't know the width (eg mintty)

        super(shortMessage);
        this.source = source;
        this.longMessage = longMessage;
    }

    /**
     * Constructs a new {@code MojoException} wrapping an underlying {@code Throwable}
     * and providing a {@code message}.
     */
    public MojoException(String message, Throwable cause) {
        super(message, cause);
    }

    /**

 * ExecutionException} when the exception thrown by a task is an unchecked exception. However, it
 * may also wrap a checked exception in some cases.
 *
 * <p>When wrapping an {@code Error} from another thread, prefer {@link ExecutionError}. When
 * wrapping a checked exception, prefer {@code ExecutionException}.
 *
 * @author Charles Fry
 * @since 10.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

}

#footer {
    margin-top: 100px;
    font-size: 80%;
    white-space: nowrap;
}

#footer, #footer a {
    color: #a0a0a0;
}

#line-wrapping-toggle {
    vertical-align: middle;
}

#label-for-line-wrapping-toggle {
    vertical-align: middle;
}

ul {
    margin-left: 0;
}

h1, h2, h3 {
    white-space: nowrap;
}

h2 {
    font-size: 120%;
}

	out[1] = 0xFFFFFE0004000000
	// ppc64x: "MOVD\t[$]-1", "SLD\t[$]48,"
	out[2] = 0xFFFF000000000000
	// ppc64x: "MOVD\t[$]65535", "SLD\t[$]44,"
	out[3] = 0x0FFFF00000000000
}

// A contiguous set of 1 bits, potentially wrapping.
func contiguousMaskConstants(out [64]uint64) {
	// ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]44, [$]63,"
	out[0] = 0xFFFFF00000000001
	// ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]43, [$]63,"
	out[1] = 0xFFFFF80000000001

/* Copyright 2011 The Go Authors. All rights reserved.
   Use of this source code is governed by a BSD-style
   license that can be found in the LICENSE file.  */

/* A trivial example of wrapping a C library using SWIG.  */

%{
#include <stdio.h>
#include <stdlib.h>
%}

%typemap(gotype) const char * "string"
%typemap(in) const char * %{
	$1 = malloc($input.n + 1);
	memcpy($1, $input.p, $input.n);
	$1[$input.n] = '\0';
%}

        tabs.select(0);

        return true;
    }

    function getCheckBox() {
        return document.getElementById("line-wrapping-toggle");
    }

    function getLabelForCheckBox() {
        return document.getElementById("label-for-line-wrapping-toggle");
    }

    function findCodeBlocks() {
        var spans = document.getElementById("tabs").getElementsByTagName("span");

        writeCursor == Cursor.at(0, text.length())
        writePos == writeCursor
        interaction { expectLineWrapCallback(startRow, text.length()) }
        0 * newLineListener._
    }

    def "completing a line wrapping will callback the listener"() {
        given:
        consoleMetaData.cols >> TERMINAL_WIDTH
        Cursor writePos = Cursor.at(1, 0)
        int startRow = writePos.row
        String text = "A" * TERMINAL_WIDTH + "B" * 2