}
            }
        }
        retries
    }

    static boolean hasCause(Throwable actual, Throwable cause) {
        if (actual == cause) {
            return true
        }
        if (actual.cause && actual.cause != actual) {
            return hasCause(actual.cause, cause)
        }
        return false
    }

            }
        }

        @Override
        public boolean isForced() {
            return hasCause(ComponentSelectionCause.FORCED);
        }

        private boolean hasCause(ComponentSelectionCause cause) {
            for (ComponentSelectionDescriptor description : descriptions) {
                if (description.getCause() == cause) {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.exceptions;

public interface NonGradleCauseExceptionsHolder {
    boolean hasCause(Class<?> type);

        }
        return message;
    }

    @Override
    public boolean hasCause(Class<?> type) {
        for (Throwable cause : getCauses()) {
            if (cause instanceof NonGradleCauseExceptionsHolder) {
                boolean hasCauseOfType = ((NonGradleCauseExceptionsHolder) cause).hasCause(type);
                if (hasCauseOfType) {
                    return true;
                }

        and: // returns metadata with no annotation present
        1 * propertyMetadata.getAnnotation(SoftwareType.class) >> Optional.empty()

        and:
        def e = thrown(DefaultMultiCauseException)
        e.hasCause(InvalidUserDataException)
    }

    def "throws exception when plugins are registered that expose multiple software types"() {
        given:
        def anotherPropertyMetadata = Mock(PropertyMetadata)

            if (hasCause(cause, type)) {
                return true;
            }
            cause = cause.getCause();
        }
        return false;
    }

    private static boolean hasCause(Throwable cause, Class<?> type) {
        if (cause instanceof NonGradleCauseExceptionsHolder) {
            return ((NonGradleCauseExceptionsHolder) cause).hasCause(type);
        }
        return false;

        }

        private static String toMessage(String description) {
            return "A failure occurred while executing " + description;
        }

        @Override
        public boolean hasCause(Class<?> type) {
            return type.isInstance(getCause());
        }
    }

    private static class WorkItemExecution extends AbstractConditionalExecution<DefaultWorkResult> implements AsyncWorkCompletion {

	// if any -NAME flag is false, run all but those analyzers.
	if multi {
		var hasTrue, hasFalse bool
		for _, ts := range enabled {
			switch *ts {
			case setTrue:
				hasTrue = true
			case setFalse:
				hasFalse = true
			}
		}

		var keep []*analysis.Analyzer
		if hasTrue {
			for _, a := range analyzers {
				if *enabled[a] == setTrue {

ThrowableCauseMatche(org.hamcrest.Matcher); public void describeTo(org.hamcrest.Description); protected boolean matchesSafely(Throwable); protected void describeMismatchSafe(Throwable, org.hamcrest.Description); public static org.hamcrest.Matcher hasCause(org.hamcrest.Matcher); } org/junit/internal/matchers/ThrowableMessageMatc.class package org.junit.internal.matchers; public synchronized class ThrowableMessageMatc extends org.hamcrest.TypeSafeMatcher { private final org.hamcrest.Matcher matcher;...