for (T input : inputs) {
          A newAccum = collector.supplier().get();
          collector.accumulator().accept(newAccum, input);
          accum = collector.combiner().apply(accum, newAccum);
        }
        return accum;
      }
    },
    /** Get one accumulator for each element and merge the accumulators right-to-left. */
    MERGE_RIGHT_ASSOCIATIVE {
      @Override

        every {
            buildType.steps(capture(stepsCapturer))
        } answers {
            stepsCapturer.captured(steps)
            mockk()
        }
    }

    @Test
    fun `can apply defaults to configurations`() {
        applyDefaults(buildModel, buildType, "myTask")

        assertEquals(
            listOf(
                "KILL_LEAKED_PROCESSES_FROM_PREVIOUS_BUILDS",

            import org.gradle.api.internal.tasks.testing.TestResultProcessor

            plugins {
                id("gradlebuild.ci-reporting")
            }

            subprojects {
                apply(plugin = "gradlebuild.ci-reporting")
            }

            project(":failed-test-with-leftover").configureTestWithLeftover(false, true)
            project(":flaky-test-with-leftover").configureTestWithLeftover(true, true)

    testImplementation("org.objenesis:objenesis")
}

tasks.withType<GroovyCompile>().configureEach {
    groovyOptions.apply {
        encoding = "utf-8"
        forkOptions.jvmArgs?.add("-XX:+HeapDumpOnOutOfMemoryError")
    }
    options.apply {
        isFork = true
        encoding = "utf-8"
        compilerArgs = mutableListOf("-Xlint:-options", "-Xlint:-path")
    }
}

    return predicate.apply(immutableEntry(key, value));
  }

  final class ValuePredicate implements Predicate<V> {
    @ParametricNullness private final K key;

    ValuePredicate(@ParametricNullness K key) {
      this.key = key;
    }

    @Override
    public boolean apply(@ParametricNullness V value) {
      return satisfies(key, value);
    }
  }

    KEY {
      @Override
      @CheckForNull
      public Object apply(Entry<?, ?> entry) {
        return entry.getKey();
      }
    },
    VALUE {
      @Override
      @CheckForNull
      public Object apply(Entry<?, ?> entry) {
        return entry.getValue();
      }
    };
  }

  @SuppressWarnings("unchecked")

    }

    fun name(name: String) =
      apply {
        require(name.trim() == name) { "name is not trimmed" }
        this.name = name
      }

    fun value(value: String) =
      apply {
        require(value.trim() == value) { "value is not trimmed" }
        this.value = value
      }

    fun expiresAt(expiresAt: Long) =
      apply {
        var expiresAt = expiresAt

    @Test
    void testDefaultPolicy() throws Exception {
        MetadataGraphEdge res;

        res = policy.apply(e1, e2);
        assertEquals("1.1", res.getVersion(), "Wrong depth edge selected");

        res = policy.apply(e1, e3);
        assertEquals("1.2", res.getVersion(), "Wrong version edge selected");
    }

            String name = (String) e.nextElement();
            String value = props.getProperty(name);
            if (value == null) {
                value = callback.apply(name);
            }
            if (name.startsWith(OVERRIDE_PREFIX)) {
                String overrideName = name.substring(OVERRIDE_PREFIX.length());

                v = cb.apply(s.substring(prefix.length()));
            }
            return v;
        };
    }

    @SafeVarargs
    @Nonnull
    public static Function<String, String> or(Function<String, String>... callbacks) {
        return s -> {
            for (Function<String, String> cb : callbacks) {
                String r = cb.apply(s);
                if (r != null) {