*         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);
            }
        }

    private final JavadocConverter javadocConverter
    private final ClassDocBuilder docBuilder
    private final LinkedList<String> currentlyBuilding = new LinkedList<String>()

    DslDocModel(File classDocbookDir, Document document, ClassMetaDataRepository<ClassMetaData> classMetaData, Map<String, gradlebuild.docs.dsl.docbook.model.ClassExtensionMetaData> extensionMetaData) {

        return returnType;
    }

    public void setReturnType(TypeMetaData returnType) {
        this.returnType = returnType;
    }

    public MethodMetaData getOverriddenMethod() {
        LinkedList<ClassMetaData> queue = new LinkedList<ClassMetaData>();
        queue.add(ownerClass.getSuperClass());
        queue.addAll(ownerClass.getInterfaces());

        String overrideSignature = getOverrideSignature();

        lexer.visit(new VisitorImpl(visitor));
    }

    private class VisitorImpl extends TokenVisitor {
        private final TokenVisitor visitor;
        private final LinkedList<String> elementStack = new LinkedList<String>();
        private final Map<String, String> attributes = new HashMap<String, String>();

        public VisitorImpl(TokenVisitor visitor) {
            this.visitor = visitor;
        }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package model

import java.util.LinkedList

/**
 * Split a list of elements into nearly even sublist. If an element is too large, largeElementSplitFunction will be used to split the large element into several smaller pieces;

     * Creates and returns a new instance of {@link LinkedList}.
     *
     * @param <E> the element type of {@link LinkedList}
     * @return a new instance of {@link LinkedList}
     * @see LinkedList#LinkedList()
     */
    public static <E> LinkedList<E> newLinkedList() {
        return new LinkedList<>();
    }

    /**
     * Creates and returns a new instance of {@link LinkedList}.
     *

      @Override
      protected Iterator<Integer> newTargetIterator() {
        return Iterables.consumingIterable(new LinkedList<>(items)).iterator();
      }
    }.test();
  }

  public void testConsumingIterable_queue_removesFromQueue() {
    Queue<Integer> queue = new LinkedList<>(asList(5, 14));

    Iterator<Integer> consumingIterator = Iterables.consumingIterable(queue).iterator();

    /** Response timeout in milliseconds */
    int RESPONSE_TIMEOUT = Config.getInt("jcifs.smb1.smb.client.responseTimeout", DEFAULT_RESPONSE_TIMEOUT);

    /** List of active connections */
    LinkedList CONNECTIONS = new LinkedList();

    /** Session limit */
    int SSN_LIMIT = Config.getInt("jcifs.smb1.smb.client.ssnLimit", DEFAULT_SSN_LIMIT);
    /** Socket timeout in milliseconds */

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.crawler.client;

import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.fess.crawler.container.CrawlerContainer;

import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.buildSteps.script
import java.io.File
import java.util.LinkedList
import java.util.Locale

interface PerformanceTestBucketProvider {
    fun createPerformanceTestsFor(
        stage: Stage,
        performanceTestCoverage: PerformanceTestCoverage,
    ): List<PerformanceTest>