subscribe(type);
        return registerLazyAddDecoratedAction(decorated);
    }

    private Action<? super T> registerLazyAddDecoratedAction(Action<? super T> decorated) {
        addActions = addActions.add(decorated);
        return decorated;
    }

    private void registerRemoveDecoratedAction(Action<? super T> decorated) {

    private final ScriptPlugin decorated;
    private final BuildOperationRunner buildOperationRunner;
    private final UserCodeApplicationContext userCodeApplicationContext;

    public BuildOperationScriptPlugin(ScriptPlugin decorated, BuildOperationRunner buildOperationRunner, UserCodeApplicationContext userCodeApplicationContext) {
        this.decorated = decorated;
        this.buildOperationRunner = buildOperationRunner;

        !(bean instanceof IConventionAware)
        !(bean instanceof GroovyObject)
    }

    def "can create decorated and undecorated subclasses of same class"() {
        def services = Stub(ServiceLookup)
        services.get(Number) >> 12

        expect:

		pod, ok := e.Object.(*example.Pod)
		if !ok {
			t.Fatalf("Should received object of type *api.Pod, get type (%T)", e.Object)
		}
		if pod.Annotations["decorated"] != "true" {
			t.Fatalf("pod.Annotations[\"decorated\"], want=%s, get=%s", "true", pod.Labels["decorated"])
		}
		if e.Type != watchType {
			t.Fatalf("expected type %s, got %s", watchType, e.Type)
		}
	case <-time.After(wait.ForeverTestTimeout):

                        decorated << toolProvider
                    }
                    return toolProvider
                }

                void undecorateToolProviders() {
                    decorated.each { toolProvider ->
                        Field workerLeaseService = toolProvider.getClass().getDeclaredField("workerLeaseService")

    /**
     * Creates an {@link ExecAction} that is not decorated. Use this when the action is not made visible to the DSL.
     * If you need to make the action visible to the DSL, use {@link org.gradle.process.ExecOperations} instead.
     */
    ExecAction newExecAction();

    /**
     * Creates a {@link JavaExecAction} that is not decorated. Use this when the action is not made visible to the DSL.

    }

    /**
     * Gradle decoration does not generate correct Kotlin metadata for decorated Kotlin types.
     * Because of that, decorated types do not appear as subtypes of the original types when inspected with Kotlin reflection.
     * Workaround: use Java reflection to determine the supertypes.
     * TODO: Either fix Kotlin metadata in decorated classes or introduce generic utilities
     */
    private

import org.gradle.internal.reflect.Instantiator;

import java.lang.reflect.Modifier;

/**
 * An instantiator that uses the correct instantiation scheme depending on the plugin type.  This allows
 * us to use a decorated instantiator for types that need it (such as software type plugins) and continue
 * using the injected instantiator for types that do not need it (such as plugin types marked as final).
 */
@NonNullApi

    def buildOperationScriptPlugin = new BuildOperationScriptPlugin(decoratedScriptPlugin, buildOperationRunner, userCodeApplicationContext)
    def target = "Test Target"

    def "delegates to decorated script plugin via build operation"() {
        when:
        buildOperationScriptPlugin.apply(target)

        then:
        2 * scriptSource.getResource() >> scriptSourceResource

        def action = Mock(Action)
        def deferred = Mock(Action)
        def id1
        def decorated

        when:
        context.apply(source, action)

        then:
        1 * action.execute(_) >> { UserCodeApplicationId id ->
            id1 = id
            decorated = context.current().reapplyLater(deferred)
        }
        0 * deferred._

        and: