}

class QueryAndMutateFromWithTypeAllTaskContainerIntegrationTest extends QueryAndMutateFromWithTypeAllDomainObjectContainerIntegrationTest implements AbstractTaskContainerIntegrationTest {

    }

    private static class SnapshotImpl implements Snapshot {
        private final boolean enabled;
        private final LogLevel logLevel;

        public SnapshotImpl(boolean enabled, LogLevel logLevel) {
            this.enabled = enabled;
            this.logLevel = logLevel;
        }
    }

    private static class OutputEventDestination implements StandardOutputListener {

    public void registerSettingsServices(ServiceRegistration registration) {
        registration.addProvider(new VersionControlSettingsServices());
    }

    private static class VersionControlBuildTreeServices implements ServiceRegistrationProvider {
        @Provides

        to meet the notification object interfaces.
        Instead, the base types like BuildOperationDescriptor should implement them natively.
        However, this will require restructuring this type and associated things such as
        OperationStartEvent. This will happen later.
     */
    private static class Adapter implements BuildOperationListener {

        private final BuildOperationNotificationListener notificationListener;

	Status *StatusREST
	Proxy  *noderest.ProxyREST

	KubeletConnectionInfo client.ConnectionInfoGetter
}

// REST implements a RESTStorage for nodes.
type REST struct {
	*genericregistry.Store
	connection     client.ConnectionInfoGetter
	proxyTransport http.RoundTripper
}

// StatusREST implements the REST endpoint for changing the status of a node.
type StatusREST struct {
	store *genericregistry.Store
}

// license that can be found in the LICENSE file.

package norm

import (
	"unicode/utf8"

	"golang.org/x/text/transform"
)

// Reset implements the Reset method of the transform.Transformer interface.
func (Form) Reset() {}

// Transform implements the Transform method of the transform.Transformer
// interface. It may need to write segments of up to MaxSegmentSize at once.

import org.gradle.internal.Cast;
import org.gradle.internal.typeconversion.NotationParser;
import org.gradle.vcs.VcsMapping;
import org.gradle.vcs.VcsMappings;

import javax.inject.Inject;

public class DefaultVcsMappings implements VcsMappings {
    private final VcsMappingsStore vcsMappings;
    private final Gradle gradle;
    private final NotationParser<Object, ModuleIdentifier> notationParser;
    private final Object lock = new Object();

import org.gradle.tooling.provider.model.ToolingModelBuilder;
import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry;

/**
 * A plugin that exposes a custom tooling model.
 */
public class CustomPlugin implements Plugin<Project> {
    private final ToolingModelBuilderRegistry registry;

    /**
     * Need to use a {@link ToolingModelBuilderRegistry} to register the custom tooling model, so inject this into
     * the constructor.

	statusStore.UpdateStrategy = job.StatusStrategy
	statusStore.ResetFieldsStrategy = job.StatusStrategy

	return &REST{store}, &StatusREST{store: &statusStore}, nil
}

// Implement CategoriesProvider
var _ rest.CategoriesProvider = &REST{}

// Categories implements the CategoriesProvider interface. Returns a list of categories a resource is part of.
func (r *REST) Categories() []string {
	return []string{"all"}
}

        outputContains("thing2: thing2")
    }

    def "plugin can create named instances of abstract class"() {
        buildFile << """
            abstract class Thing implements Named { }

            class CustomPlugin implements Plugin<Project> {
                void apply(Project project) {
                    project.tasks.create('thing1', CustomTask) {
                        thing = project.objects.named(Thing, 'thing1')