public void test_execute_maxProcessesExceeded() {
        // Setup test
        crawlJob = new CrawlJob() {
            @Override
            protected int getRunningJobCount() {
                return 10; // More than max
            }
        };

        ComponentUtil.setFessConfig(new TestFessConfig() {
            @Override
            public Integer getJobMaxCrawlerProcessesAsInteger() {
                return 5;

 * singleton and regular maps respectively. For sorted maps, it's a thin wrapper around {@link
 * java.util.TreeMap}.
 *
 * @see ImmutableSortedMap
 * @author Hayward Chan
 */
public abstract class ImmutableMap<K, V> implements Map<K, V>, Serializable {

  abstract static class IteratorBasedImmutableMap<K, V> extends ImmutableMap<K, V> {

                    .relocation(model.getDistributionManagement().getRelocation())
                    .build());
        }
        // only keep repositories other than 'central'
        builder.repositories(pruneRepositories(model.getRepositories()));
        builder.pluginRepositories(null);
        return builder;
    }

pkg context, type CancelFunc func()
pkg context, type Context interface { Deadline, Done, Err, Value }
pkg context, type Context interface, Deadline() (time.Time, bool)
pkg context, type Context interface, Done() <-chan struct
pkg context, type Context interface, Err() error
pkg context, type Context interface, Value(interface{}) interface{}
pkg context, var Canceled error
pkg context, var DeadlineExceeded error

square-kotlin-poet = "2.3.0"
square-moshi = "1.15.2"
square-okio = "3.17.0"
square-retrofit = "3.0.0"
startup-runtime = "1.2.0"
testcontainers = "1.21.4"
zstd-kmp-okio = "0.4.0"

# Set to lower version than KGP version to maximize compatibility
# Default to matching okio
kotlinCoreLibrariesVersion = "2.1.21"

[libraries]

import jsinterop.annotations.JsMethod;
import org.jspecify.annotations.Nullable;

/**
 * GWT emulated version of {@link com.google.common.collect.ImmutableList}. TODO(cpovirk): more doc
 *
 * @author Hayward Chan
 */
@SuppressWarnings("serial") // we're overriding default serialization
public abstract class ImmutableList<E> extends ImmutableCollection<E>
    implements List<E>, RandomAccess {

  ImmutableList() {}

		rng.Shuffle(len(vers), func(i, j int) {
			vers[i], vers[j] = vers[j], vers[i]
		})
		var entries []chan metaCacheEntry
		for _, v := range vers {
			v.cached = nil
			ch := make(chan metaCacheEntry, 1)
			ch <- v
			close(ch)
			entries = append(entries, ch)
		}
		out := make(chan metaCacheEntry, 1)
		err := mergeEntryChannels(t.Context(), entries, out, 1)
		if err != nil {
			t.Fatal(err)

 * </ul>
 *
 * <p>This class uses (possibly repeated) invocations of {@link java.lang.System#gc()} to cause
 * finalization to happen. However, a call to {@code System.gc()} is specified to be no more than a
 * hint, so this technique may fail at the whim of the JDK implementation, for example if a user
 * specified the JVM flag {@code -XX:+DisableExplicitGC}. But in practice, it works very well for
 * ordinary tests.
 *

 * the columns. The reverse is also available, associating a column with a row key / value map. Note
 * that, in some implementations, data access by column key may have fewer supported operations or
 * worse performance than data access by row key.
 *
 * <p>The methods returning collections or maps always return views of the underlying table.
 * Updating the table can change the contents of those collections, and updating the collections

                event.getSession()
                        .getResult()
                        .addException(
                                new Exception("Build failed due to log statements with a higher severity than allowed. "
                                        + "Fix the logged issues or remove flag --fail-on-severity (-fos)."));
            }

            logResult(event.getSession());