import gradlebuild.AbstractBuildScanInfoCollectingService
import gradlebuild.registerBuildScanInfoCollectingService
import io.gitlab.arturbosch.detekt.Detekt
import org.gradle.tooling.events.task.TaskFailureResult
import org.gradle.tooling.events.task.TaskOperationResult
import java.io.Serializable
import java.util.concurrent.CopyOnWriteArrayList

/**

    implements SetMultimap<K, V> {
  /**
   * Returns a {@link Collector} that accumulates elements into an {@code ImmutableSetMultimap}
   * whose keys and values are the result of applying the provided mapping functions to the input
   * elements.
   *
   * <p>For streams with defined encounter order (as defined in the Ordering section of the {@link
   * java.util.stream} Javadoc), that order is preserved, but entries are <a

import org.apache.maven.project.MavenProject;

/**
 * Lifecycle mapping delegate component interface. Calculates project build execution plan given {@link Lifecycle} and
 * lifecycle phase. Standard lifecycles use plugin execution {@code <phase>} or mojo default lifecycle phase to
 * calculate the execution plan, but custom lifecycles can use alternative mapping strategies.
 * <p>

    void mapsKnownDosCodesToNtStatus(int dosCode, int expectedNtStatus) {
        // Act
        int actual = findNtStatusOrMinusOne(dosCode);

        // Assert
        assertEquals(expectedNtStatus, actual, "Mapping must match table entry");
    }

    @Test
    @DisplayName("Edge: zero DOS code maps to zero NTSTATUS")
    void zeroCodeMapsToZero() {
        // Act
        int actual = findNtStatusOrMinusOne(0x00000000);

   *
   * Our usages should at least be *relatively* safe: Typically, threads started by a test are dying
   * at the end of the test, so there is no object state put at risk by stopping the threads
   * abruptly. In other cases, a test may put a thread into an uninterruptible operation
   * intentionally, so there is no other way to clean up these threads. (The better solution,

                .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));
        sourceMap.put("searchField", searchFieldMap);
        final Map<String, List<String>> headerMap = headerList.stream()
                .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));
        sourceMap.put("headers", headerMap);

// Bean metadata introspection
BeanDesc beanDesc = BeanDescFactory.getBeanDesc(MyBean.class);
PropertyDesc nameProperty = beanDesc.getPropertyDesc("name");
nameProperty.setValue(bean, "John Doe");

// Bean copying with flexible options
BeanUtil.copyBeanToBean(source, destination);
BeanUtil.copyBeanToBean(source, destination, options -> 
    options.exclude("password", "internalId"));

// Convert between beans and maps

    if [ -n "$pid" ]; then
        echo $pid > "$pidfile"
    fi
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "
    # stop it here, often "killproc $prog"
    killproc -p $pidfile -d 20 $prog
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}

restart() {

 * the offending characters.
 *
 * ### IDNA Mapping and Punycode encoding
 *
 * Hostnames have different requirements and use a different encoding scheme. It consists of IDNA
 * mapping and Punycode encoding.
 *
 * In order to avoid confusion and discourage phishing attacks, [IDNA Mapping][idna] transforms

### Build execution model

Gradle generally does some work in response to a client request. There are several different clients, for example the `gradlew` command or the tooling API client, 
that can send requests to a Gradle daemon.
Each daemon runs one request at a time. Generally speaking, the daemons only act in response to a request from a client and do not take any action on their own.