public List<InetAddress> getCandidates() {
        return Collections.singletonList(address);
    }

    public InetAddress getAddress() {
        return address;
    }

    @Override
    public int getPort() {
        return port;
    }

    private static class Serializer implements org.gradle.internal.serialize.Serializer<SocketInetAddress> {

        @Override

            for (Class<?> dependency : rules.getRequiredPlugins()) {
                target.getPluginManager().apply(dependency);
            }
            modelRegistry.getRoot().applyToSelf(rules);
        }
    }

    @Override
    public void applyImperativeRulesHybrid(@Nullable String pluginId, Plugin<?> plugin, Class<?> declaringClass) {
        applyImperative(pluginId, plugin);

import org.apache.maven.api.annotations.Provider;

/**
 * Represents a dependency node within a Maven project's dependency collector.
 *
 * @since 4.0.0
 * @see org.apache.maven.api.services.DependencyResolverResult#getRoot()
 */
@Experimental
@Immutable
@Provider
public interface Node {

    /**
     * @return artifact for this node
     */
    @Nullable
    Artifact getArtifact();

    /**

@Measurement(iterations = 10, time = 1, timeUnit = SECONDS)
@State(Scope.Benchmark)
public class OptionalBenchmark {

    final Path path = Paths.get(".");
    final Path pathRoot = Paths.get(".").toAbsolutePath().getRoot();

    @Benchmark
    public void nullCheck(Blackhole bh) {
        bh.consume(nullCheck(path));
        bh.consume(nullCheck(pathRoot));
    }

    private static Object nullCheck(Path path) {

        assertEquals(TaskOutcome.SUCCESS, result.task(":jar")?.outcome)
        assertEquals(TaskOutcome.SUCCESS, result.task(":publishLibraryPublicationToTestRepoRepository")?.outcome)
        assertTrue(File(testProjectDir.getRoot(), "build/test-repo/com/example/my-library/0.1.0/my-library-0.1.0.jar").exists())
    }

    @Test
    fun `fails when no README exists`() {
        val result = runTaskWithFailure ("check")

        String response = checkGetMethod(searchBody, "").asString();
        final int total = JsonPath.from(response).getInt("response.total");
        final List<Map<String, String>> dicts = JsonPath.from(response).getList("response.settings");
        final int status = JsonPath.from(response).getInt("response.status");
        assertEquals(total, dicts.size());
        assertEquals(0, status);
    }

    @Override

        }
        if (type.equals(Type.LONG_TYPE)) {
            return ClassName.LONG;
        }
        if (type.equals(Type.DOUBLE_TYPE)) {
            return ClassName.DOUBLE;
        }
        if (type.getSort() == Type.ARRAY) {
            return ArrayTypeName.of(typeName(type.getElementType()));
        }
        return className(type);
    }

    public static ClassName className(Type type) {

		Predicate:            pred,
		Recursive:            true,
	}
	ctx := context.Background()
	if lw.contextMetadata != nil {
		ctx = metadata.NewOutgoingContext(ctx, lw.contextMetadata)
	}
	if err := lw.storage.GetList(ctx, lw.resourcePrefix, storageOpts, list); err != nil {
		return nil, err
	}
	return list, nil
}

// Implements cache.ListerWatcher interface.

                credentialsProvider.setCredentials(authScope, authentication.getCredentials());
                if (authScope.getHost() != null && authScheme != null) {
                    final HttpHost targetHost = new HttpHost(authScope.getHost(), authScope.getPort());
                    authCache.put(targetHost, authScheme);
                }
            }
        }

                attachMultipleForceOnPlatformFailureToEdges(module);
            }
        }
        List<EdgeState> incomingRootEdges = resolveState.getRoot().getIncomingEdges();
        if (!incomingRootEdges.isEmpty()) {
            String rootNodeName = resolveState.getRoot().getMetadata().getName();
            DeprecationLogger.deprecate(
                    String.format(