import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class StreamUtil {
    private StreamUtil() {
        // nothing
    }

    @SafeVarargs
    public static <T> StreamOf<T> stream(final T... values) {
        return new StreamOf<>(() -> values != null ? Arrays.stream(values) : Collections.<T> emptyList().stream());
    }

     */
    public fun substituteOrNull(type: KaType): KaType?

    /**
     * [KaSubstitutor] which does nothing on a type and always returns the type intact
     */
    public class Empty(override val token: KaLifetimeToken) : KaSubstitutor {
        override fun substituteOrNull(type: KaType): KaType? = withValidityAssertion { null }

    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        return updateMap;
    }

    @AfterEach
    protected void tearDown() {
        // do nothing
    }

    @Test
    void testList_ok() {
        checkGetMethod(Collections.emptyMap(), getListEndpointSuffix() + "/").then().body("response.status", equalTo(0));
    }

		if errors.IsNotFound(err) {
			logger.V(5).Info("Ephemeral: nothing to do for pod, it is gone", "podKey", key)
			return nil
		}
		logger.V(5).Info("Error getting pod from informer", "pod", klog.KObj(pod), "podUID", pod.UID, "err", err)
		return err
	}

	// Ignore pods which are already getting deleted.
	if pod.DeletionTimestamp != nil {
		logger.V(5).Info("Ephemeral: nothing to do for pod, it is marked for deletion", "podKey", key)

    }

    void "nothing happens if project was already configured"() {
        given:
        state.configured()

        when:
        evaluate()

        then:
        state.executed
        0 * delegate._

        and:
        operations.empty
    }

    void "nothing happens if project is being configured now"() {
        given:

        assertEquals(new Integer(0), JsonPath.from(response).get("response.status"));
    }

    @Override
    protected void tearDown() {
        // do nothing
    }

    @Test
    void crudTest() {
        testRead();
    }

        }.run { builder ->
            builder.addProgressListener(new ProgressListener() {
                @Override
                void statusChanged(ProgressEvent event) {
                    // do nothing, just force the daemon to send all events
                }
            })
            builder.addArguments("compileJava")
            builder.run()
        }

        when:
        def result = runner.run()

        assertEquals(new Integer(0), JsonPath.from(response).get("response.status"));
    }

    @Override
    protected void tearDown() {
        // do nothing
    }

    @Test
    void crudTest() {
        testRead();
    }

When isolated projects is enabled, Gradle applies two levels of caching during IDE sync:

Gradle starts by applying coarse-grained caching.
To do this, Gradle caches the result of the entire sync operation and reuses it when nothing that affects the IDE model has changed.
When the cache entry can be reused, Gradle short-circuits the entire sync operation and simply returns the cached result to the IDE.

  public void testAddAll_supportedNothing() {
    assertFalse("addAll(nothing) should return false", collection.addAll(emptyCollection()));
    expectUnchanged();
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  public void testAddAll_unsupportedNothing() {
    try {
      assertFalse(
          "addAll(nothing) should return false or throw", collection.addAll(emptyCollection()));