15: "terminated",
	16: "user Signal 1",
	17: "user Signal 2",
	18: "child Status Changed",
	19: "power-Fail/Restart",
	20: "window Size Change",
	21: "urgent Socket Condition",
	22: "pollable Event",
	23: "stopped (signal)",
	24: "stopped (user)",
	25: "continued",
	26: "stopped (tty input)",
	27: "stopped (tty output)",
	28: "virtual Timer Expired",
	29: "profiling Timer Expired",

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.inject.Inject;
import java.io.File;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.concurrent.Callable;

import static com.google.common.base.Strings.isNullOrEmpty;

     *
     * <p>The provider is live and will call the {@link Callable} each time its value is queried. The {@link Callable} may return {@code null}, in which case the provider is considered to have no value.
     *
     * @param value The {@link Callable} use to calculate the value.
     * @return The provider. Never returns null.
     * @see org.gradle.api.provider.ProviderFactory#provider(Callable)
     * @since 4.0
     */

   */
  public static <K extends @Nullable Object, V extends @Nullable Object> Multimap<K, V> newMultimap(
      Map<K, Collection<V>> map, final Supplier<? extends Collection<V>> factory) {
    return new CustomMultimap<>(map, factory);
  }

  private static class CustomMultimap<K extends @Nullable Object, V extends @Nullable Object>
      extends AbstractMapBasedMultimap<K, V> {

    }

    private static FailureContainer toFailureContainer(@Nullable InternalBasicProblemDetailsVersion3 problemDetails) {
        return toFailureContainer(problemDetails == null ? null : problemDetails.getFailure());
    }

    private static FailureContainer toFailureContainer(@Nullable InternalFailure failure) {
        if (failure == null) {
            return new DefaultFailureContainer(null);

            }
            excludedByEither.add(constraintExclusions);
        }
        return excludedByEither;
    }

    @Nullable
    private ExcludeSpec joinNodeExclusions(@Nullable ExcludeSpec nodeExclusions, @Nullable Set<ExcludeSpec> excludedByEither) {
        if (excludedByEither != null) {
            if (nodeExclusions != null) {
                excludedByEither.add(nodeExclusions);

   * @since 12.0
   */
  public static <E extends @Nullable Object> NavigableSet<E> unmodifiableNavigableSet(
      NavigableSet<E> set) {
    if (set instanceof ImmutableCollection || set instanceof UnmodifiableNavigableSet) {
      return set;
    }
    return new UnmodifiableNavigableSet<>(set);
  }

  static final class UnmodifiableNavigableSet<E extends @Nullable Object>

        0 * _

        and:
        result == someValue()
        present
    }

    def "replaces provider with fixed value on next query of nullable value when value implicitly finalized"() {
        def property = propertyWithNoValue()
        def function = Mock(Callable)
        def provider = new DefaultProvider<T>(function)

        given:
        property.set(provider)

        when:

            @Provides
            Integer createInteger(Callable<Integer> factory) {
                return factory.call()
            }

            @Provides
            String createString(Callable<String> factory) {
                return factory.call()
            }

            @Provides
            Callable<Integer> createIntFactory() {
                return { 123 }
            }

        Supplier<T> s = asSupplier(supplier);
        if (cache == null) {
            return s.get();
        } else {
            return cache.computeIfAbsent(groupId, artifactId, version, tag, s);
        }
    }

    private static <T> T cache(ModelCache cache, Source source, String tag, Callable<T> supplier) {