import org.hamcrest.CoreMatchers
import spock.lang.Issue

import static org.hamcrest.CoreMatchers.containsString
import static org.hamcrest.MatcherAssert.assertThat

@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = NOT_EMBEDDED_REASON)
class WrapperProjectIntegrationTest extends AbstractWrapperIntegrationSpec {
    def setup() {
        file("build.gradle") << """
    task hello {
        doLast {
            println 'hello'

	for _, c := range status.GetConditions() {
		conditions = append(conditions, kubecontainer.RuntimeCondition{
			Type:    kubecontainer.RuntimeConditionType(c.Type),
			Status:  c.Status,
			Reason:  c.Reason,
			Message: c.Message,
		})
	}
	retHandlers := make([]kubecontainer.RuntimeHandler, len(handlers))
	for i, h := range handlers {
		supportsRRO := false
		supportsUserns := false

    EmptyLineTrimmerOutputNormalizer.class
})
@SampleModifiers({
    SetMirrorsSampleModifier.class,
    MoreMemorySampleModifier.class
})
@Requires(value = UnitTestPreconditions.KotlinOnlySupportsJdk21Earlier.class, reason = "Kotlin cannot compile on Java 22 in samples yet")
/*
 * To run the samples tests:
 *
 * Say you want to run the snippet found at:
 *    src/snippets/dependencyManagement/customizingResolution-consistentResolution
 *

        'validation:type-validation:invalid-use-of-type-annotation' : 'Incorrect use of type annotation',
        'validation:type-validation:not-cacheable-without-reason' : 'Not cacheable without reason',

	// +optional
	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,4,opt,name=lastTransitionTime"`
	// (brief) reason for the condition's last transition.
	// +optional
	Reason string `json:"reason,omitempty" protobuf:"bytes,5,opt,name=reason"`
	// Human readable message indicating details about last transition.
	// +optional
	Message string `json:"message,omitempty" protobuf:"bytes,6,opt,name=message"`

 */
public class KaInapplicableCallCandidateInfo(
    candidate: KaCall,
    isInBestCandidates: Boolean,
    diagnostic: KaDiagnostic,
) : KaCallCandidateInfo(candidate, isInBestCandidates) {
    /**
     * The reason the [candidate] was not applicable for the call (e.g., argument type mismatch, or no value for parameter).
     */
    public val diagnostic: KaDiagnostic by validityAsserted(diagnostic)

            if (repositoryDisabler.isDisabled(repositoryId)) {
                Throwable reason = repositoryDisabler.getDisabledReason(repositoryId).get();
                E failure = onDisabled.transform(reason);
                result.failed(failure);
                return true;
            }
            return false;
        }

	}
	return result.Value() == true, nil
}

type fakeAuthorizer struct {
	decision authorizer.Decision
	reason   string
	err      error
}

func (f fakeAuthorizer) Authorize(ctx context.Context, a authorizer.Attributes) (authorizer.Decision, string, error) {
	return f.decision, f.reason, f.err

            qualifiers.joinToString(separator = ".") { it.name.asString() }
        }

    @KaAnalysisNonPublicApi
    override val errorMessage: String get() = withValidityAssertion { coneDiagnostic.reason }

    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }

    override val candidateSymbols: Collection<KaClassLikeSymbol> by cached {

        outputContains("Configuring ':bar'")
        outputDoesNotContain("Configuring ':included")
    }

    @Requires(
        value = IntegTestPreconditions.NotIsolatedProjects,
        reason = "accessing `tasks` from subprojects is in violation of Isolated Projects"
    )
    def "lifecycle applied build logic runs before subprojects configuration logic"() {
        given:
        settingsFile """