@Override
              public Queue<String> create(String[] elements) {
                Queue<String> queue = new LinkedList<>(MinimalCollection.of(elements));
                return Collections.checkedQueue(queue, String.class);
              }
            })
        .named("checkedQueue/LinkedList")
        .withFeatures(
            CollectionFeature.GENERAL_PURPOSE,
            CollectionFeature.ALLOWS_NULL_VALUES,

import org.gradle.tooling.BuildAction;
import org.gradle.tooling.BuildController;

import java.util.LinkedList;
import java.util.List;

public class MultipleParametersAction implements BuildAction<List<CustomModel>> {
    @Override
    public List<CustomModel> execute(BuildController controller) {
        List<CustomModel> result = new LinkedList<CustomModel>();
        final CustomModel model0 = controller.getModel(CustomModel.class);

     *         to formal types through a method invocation conversion).
     */
    private static LinkedList<Method> getApplicables(List<Method> methods, Class<?>... classes) {
        LinkedList<Method> list = new LinkedList<>();

        for (Method method : methods) {
            if (isApplicable(method, classes)) {
                list.add(method);
            }
        }

        for (DependencyGraphNode node : fromNodes) {
            directDependees.add(node.getOwner());
        }

        Set<DependencyGraphComponent> seen = new HashSet<>();
        LinkedList<DependencyGraphComponent> queue = new LinkedList<>(directDependees);
        while (!queue.isEmpty()) {
            DependencyGraphComponent version = queue.getFirst();
            if (version == toNode.getOwner()) {

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class DefaultBuildCancellationToken implements BuildCancellationToken {

    private final Object lock = new Object();
    private boolean cancelled;
    private List<Runnable> callbacks = new LinkedList<Runnable>();

    @Override
    public boolean isCancellationRequested() {

import org.gradle.internal.remote.internal.inet.InetEndpoint;
import org.gradle.launcher.daemon.context.DaemonContext;

import java.io.File;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State;

 */
package org.apache.maven.internal.impl.model;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;

class Graph {

    final Map<String, Set<String>> graph = new LinkedHashMap<>();

import java.util.LinkedList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DefaultIvyContextManager implements IvyContextManager {
    private static final int MAX_CACHED_IVY_INSTANCES = 4;
    private final Lock lock = new ReentrantLock();
    private boolean messageAdapterAttached;
    private final LinkedList<Ivy> cached = new LinkedList<>();

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class DefaultIdeaModule implements Serializable, GradleProjectIdentity {
    private String name;
    private List<DefaultIdeaContentRoot> contentRoots = new LinkedList<DefaultIdeaContentRoot>();
    private DefaultIdeaProject parent;

    private List<DefaultIdeaDependency> dependencies = new LinkedList<DefaultIdeaDependency>();

import org.gradle.platform.base.*;

import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import static java.util.Collections.emptySet;

public class DefaultDependencySpecContainer implements DependencySpecContainer {

    private final List<DependencySpecBuilder> builders = new LinkedList<DependencySpecBuilder>();

    @Override