// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

     * @param content the message to log
     * @param error the error that caused this log
     */
    void debug(CharSequence content, Throwable error);

    /**
     * Sends an exception to the user in the <b>debug</b> error level.
     * The stack trace for this exception will be output when this error level is enabled.
     *
     * @param error the error that caused this log
     */
    void debug(Throwable error);

            List<Throwable> causes = new ArrayList<>(taskExecutionException.getCauses());
            CollectionUtils.addAll(causes, failure.getCauses());
            taskExecutionException.initCauses(causes);
        } else {
            List<Throwable> causes = new ArrayList<>();
            causes.add(this.failure);
            causes.addAll(failure.getCauses());
            failure.initCauses(causes);

    private final List<Failure> suppressed;
    private final List<Failure> causes;

    public DefaultFailure(
        Throwable original,
        List<StackTraceElement> stackTrace,
        List<StackTraceRelevance> frameRelevance,
        List<Failure> suppressed,
        List<Failure> causes
    ) {
        if (stackTrace.size() != frameRelevance.size()) {

    }

    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory, Throwable... causes) {
        super(messageFactory, causes);
    }

    public DefaultMultiCauseExceptionNoStackTrace(Factory<String> messageFactory, Iterable<? extends Throwable> causes) {
        super(messageFactory, causes);
    }

    @Override
    public synchronized Throwable fillInStackTrace() {
        return this;
    }

        String actual,
        List<InternalFailure> causes,
        byte[] expectedContent,
        byte[] actualContent
    ) {
        List<InternalFailure> causeFailure;
        if (causes.isEmpty()) {
            Throwable cause = t.getCause();
            causeFailure = cause != null && cause != t ? Collections.singletonList(DefaultFailure.fromThrowable(cause)) : Collections.emptyList();
        } else {

     * Do not call this constructor.
     *
     * @deprecated This constructor will be made protected in 9.0
     */
    @Deprecated
    public ResolveException(String message, Iterable<? extends Throwable> causes) {
        super(message, causes);

        DeprecationLogger.deprecateAction("Directly instantiating a ResolveException")
            .withContext("Instantiating this exception is reserved for Gradle internal use only.")

            ImmutableList.Builder<Throwable> causes = new ImmutableList.Builder<Throwable>();
            if (parent instanceof MultiCauseException) {
                causes.addAll(((MultiCauseException) parent).getCauses());
            } else if (parent.getCause() != null) {
                causes.add(parent.getCause());
            }

            return CollectionUtils.collect(causes.build(), recursiveConverter);
        }

	if x1 == x2 {
		r = v2
	}
	return r
}

func main() {
	if cmovClobberAX16(1, 2, 4.0, 5.0) != 1 {
		panic("CMOVQEQF causes incorrect code")
	}
	if cmovClobberAX32(1, 2, 4.0, 5.0) != 1 {
		panic("CMOVQEQF causes incorrect code")
	}
	if cmovClobberAX64(1, 2, 4.0, 5.0) != 1 {
		panic("CMOVQEQF causes incorrect code")
	}

        then:
        pd1 == pd2
        pd1 == pd1
    }

    def "Changed label causes equal to be false"() {

        when:
        def pd1 = createProblemDefinition()
        def pd2 = createProblemDefinition("otherLabel")

        then:
        pd1 != pd2
    }

    def "Changed severity causes equal to be false"() {

        when:
        def pd1 = createProblemDefinition()