* limitations under the License.
 */

package org.gradle.internal.service.scopes;

import org.gradle.internal.service.ServiceRegistration;

/**
 * Base no-op implementation of the {@link GradleModuleServices}.
 */
public class AbstractGradleModuleServices implements GradleModuleServices {
    @Override
    public void registerGlobalServices(ServiceRegistration registration) {

    }

              @Override
              public String pendingToString() {
                throw new RuntimeException("I'm a misbehaving implementation");
              }
            }.toString())
        .matches(
            "[^\\[]+\\[status=PENDING, info=\\[Exception thrown from implementation: "
                + "class java.lang.RuntimeException\\]\\]");
  }

  public void testCompletionFinishesWithDone() {

 * or tasks. This property object keeps track of both the location and the task or tasks that produce the content of the element.
 *
 * <p><b>Note:</b> This interface is not intended for implementation by build script or plugin authors.</p>
 *
 * @param <T> The type of location.
 * @since 5.6
 */
@HasInternalProtocol
public interface FileSystemLocationProperty<T extends FileSystemLocation> extends Property<T> {

import org.eclipse.aether.artifact.ArtifactProperties;
import org.eclipse.aether.artifact.ArtifactType;

import static java.util.Objects.requireNonNull;

/**
 * Default implementation of {@link Type} and Resolver {@link ArtifactType}.
 *
 * @since 4.0.0
 */
public class DefaultType implements Type, ArtifactType {
    private final String id;
    private final Language language;

import org.gradle.api.Plugin;
import org.gradle.api.Project;
import org.gradle.api.initialization.Settings;

import java.util.List;

/**
 * Represents a resolved software type implementation including the public model type and the plugin that exposes it.
 */
public interface SoftwareTypeImplementation<T> {
    String getSoftwareType();

    Class<? extends T> getModelPublicType();

 * <p>
 * The meaning of the value parameter is specific to each concrete subclass. The validity of {@code null}
 * is also to be defined by each subclass. This implementation does allow null values.
 *
 * <p>The result is the last message sent from the daemon back to the daemon client.
 */
public abstract class Result<T> extends Message {

    private final T value;

        }

        @Provides
        ClassLoaderHierarchyHasher createClassLoaderHierarchyHasher() {
            // Return a dummy implementation of this as creating a real hasher drags ~20 more services
            // along with it, and a hasher isn't actually needed on the worker process side at the moment.
            return new ClassLoaderHierarchyHasher() {

 * {@link #TEST_COMPILE} and {@link #TEST_RUNTIME}, but can be extended by registering a
 * {@code org.apache.maven.api.spi.PathScopeProvider}.
 * <p>
 * Implementation must have {@code equals()} and {@code hashCode()} implemented, so implementations of this interface
 * can be used as keys.
 *
 * @since 4.0.0
 * @see org.apache.maven.api.services.DependencyResolver
 * @see DependencyScope
 */
@Experimental

  }

  /**
   * Indicates that the loading of Unsafe was successful and the load and store operations will be
   * very efficient. May be useful for calling code to fall back on an alternative implementation
   * that is slower than Unsafe.get/store but faster than the pure-Java mask-and-shift.
   */
  static boolean usingUnsafe() {
    return (byteArray instanceof UnsafeByteArray);
  }

  /**

        }
        if (implementationSnapshot instanceof UnknownImplementationSnapshot) {
            return Impl.UNKNOWN;
        }
        throw new IllegalArgumentException("Unexpected implementation snapshot type: " + implementationSnapshot.getClass().getName());
    }