package org.gradle.buildinit.plugins.internal;

import org.gradle.api.internal.DocumentationRegistry;
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitTestFramework;
import org.gradle.buildinit.plugins.internal.modifiers.Language;
import org.gradle.buildinit.plugins.internal.modifiers.ModularizationOption;
import org.gradle.internal.os.OperatingSystem;
import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform;

/**
 * Assists in firing events from a generic method by abstracting from the actual callback method to be called on the
 * listener.
 *
 */
interface ModelBuildingEventCatapult {

    /**
     * Notifies the specified listener of the given event.
     *
     * @param listener The listener to notify, must not be {@code null}.
     * @param event The event to fire, must not be {@code null}.
     */

 */

package org.gradle.buildinit.plugins.internal;

import org.gradle.api.plugins.JvmTestSuitePlugin;
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitTestFramework;
import org.gradle.buildinit.plugins.internal.modifiers.ModularizationOption;

import java.util.Collections;
import java.util.Optional;
import java.util.Set;

 * {@link AbstractModelBuildingListener} rather than to directly implement this interface.
 *
 */
public interface ModelBuildingListener {

    /**
     * Notifies the listener that the model has been constructed to the extent where build extensions can be processed.
     *
     * @param event The details about the event.
     */
    void buildExtensionsAssembled(ModelBuildingEvent event);

    private final ModelType<T> declaringType;
    private final ModelType<R> returnType;
    private final String name;
    private final ImmutableList<ModelType<?>> paramTypes;
    private final int modifiers;

    private int cachedHashCode = -1;

    private WeaklyTypeReferencingMethod(ModelType<T> declaringType, ModelType<R> returnType, Method method) {
        if (declaringType.getRawClass() != method.getDeclaringClass()) {

/**
 * Represents an object that may be owned by some model object. This is mixed-in to generated classes and may
 * also be implemented directly.
 */
public interface OwnerAware {
    /**
     * Notifies this object that it now has an owner associated with it.
     *
     * @param owner The owner object, if any.
     * @param displayName The display name for this object.
     */

)

// EventHandler allows for generic monitoring of xDS ACKS and disconnects, for the purpose of tracking
// Config distribution through the mesh.
type DistributionStatusCache interface {
	// RegisterEvent notifies the implementer of an xDS ACK, and must be non-blocking
	RegisterEvent(conID string, eventType EventType, nonce string)
	RegisterDisconnect(s string, types sets.Set[EventType])

        collect(result, c.superclass)
    }

    private boolean isPublicApi(CtMethod method) {
        return Modifier.isPublic(method.modifiers) || Modifier.isProtected(method.modifiers)
    }

    private List<String> filterChangesToReport(CtClass c, Set<CtMethod> methods) {
        return methods.findAll { isFirstPublicClassInHierarchy(it, c) }*.longName.sort()
    }

trait TestAnnotationHandlingSupport {

    enum Modifiers implements AnnotationCategory {
        COLOR;

        @Override
        String getDisplayName() {
            name()
        }
    }

    TypeAnnotationMetadataStore typeAnnotationMetadataStore = new DefaultTypeAnnotationMetadataStore(
        [ThisIsAThing],
        [(TestNested): TYPE, (Long): TYPE, (Short): TYPE, (Tint): Modifiers.COLOR],
        ["java", "groovy"],

import org.gradle.api.internal.tasks.properties.ValidationActions
import org.gradle.internal.properties.PropertyValue
import spock.lang.Specification

class DefaultFinalizingValidatingPropertyTest extends Specification {
    def "notifies property value of start and end of execution when it implements lifecycle interface"() {
        def value = Mock(LifecycleAwareValue)
        def valueWrapper = Stub(PropertyValue)