final String script = "def sum = 0; for (int i = 1; i <= n; i++) { sum += i }; return sum";
        assertEquals(15, groovyEngine.evaluate(script, params));
    }

    /**
     * Test that closures work
     */
    @Test
    public void test_evaluate_closures() {
        final Map<String, Object> params = new HashMap<>();
        final String script = "def multiply = { x, y -> x * y }; return multiply(6, 7)";

    /**
     * Repeatedly match the pattern to the string, calling the closure with the
     * matchers each time there is a match. If there are characters that don't
     * match then blow up. If the closure takes two parameters then the second
     * one is "is this the last match?".
     */
    protected parse(String location, String s, String pattern, Closure c) {
        if (s == null) {

        // Using a SmbComClose instance triggers early return without DFS/session work
        SmbComClose closeReq = mock(SmbComClose.class);
        SmbResourceLocator res = c.ensureDFSResolved(loc, closeReq);
        assertSame(loc, res);
        // No connect attempts expected
        verify(c, never()).connectWrapException(any());
    }

    @Test

 * <p>An exception that is suppressed is added to the exception that <i>will</i> be thrown using
 * {@code Throwable.addSuppressed(Throwable)}.
 *
 * @author Colin Decker
 * @since 14.0
 */
// Coffee's for {@link Closer closers} only.
@J2ktIncompatible
@GwtIncompatible
public final class Closer implements Closeable {
  /** Creates a new {@link Closer}. */
  public static Closer create() {
    return new Closer(SUPPRESSING_SUPPRESSOR);
  }

     */
    protected boolean spawn = true

    /**
     * A closure to call before the fixture is considered ready. The closure is passed the fixture object,
     * as well as a groovy AntBuilder, to enable running ant condition checks. The default wait
     * condition is for http on the http port.
     */
    @Internal
    Closure waitCondition = { AntFixture fixture, AntBuilder ant ->

    // edges, so this traversal would require reusing the undirected AB edge.
    return false;
  }

  /**
   * Returns the transitive closure of {@code graph}. The transitive closure of a graph {@code G} is
   * a graph {@code T} that is a supergraph of {@code G}, augmented by, for each pair of nodes A and

 * in compliance with, at your election, the Elastic License 2.0 or the Server
 * Side Public License, v 1.
 */
package org.elasticsearch.gradle.internal.precommit;

import groovy.lang.Closure;
import org.elasticsearch.gradle.util.GradleUtils;
import org.elasticsearch.gradle.internal.conventions.util.Util;
import org.gradle.api.DefaultTask;
import org.gradle.api.NamedDomainObjectContainer;

        }, "Multiple close operations should not cause issues");

        // Verify iterator still works after multiple closes
        assertFalse(emptyIterator.hasNext(), "Iterator should still work after multiple closes");
        assertNull(emptyIterator.next(), "Iterator should still return null after multiple closes");
    }

    @Test
    @DisplayName("EmptyIterator should handle remove operations multiple times")

// to the peer.
type WriteOnCloser struct {
	io.Writer
	hasWritten bool
}

func (w *WriteOnCloser) Write(p []byte) (int, error) {
	w.hasWritten = true
	return w.Writer.Write(p)
}

// Close closes the WriteOnCloser. It behaves like io.Closer.
func (w *WriteOnCloser) Close() error {
	if !w.hasWritten {
		_, err := w.Write(nil)
		if err != nil {
			return err
		}
	}

    public LicenseHeadersTask() {
        setDescription("Checks sources for missing, incorrect, or unacceptable license headers");
    }

    /**
     * The list of java files to check. protected so the afterEvaluate closure in the
     * constructor can write to it.
     */
    @InputFiles
    @SkipWhenEmpty
    @PathSensitive(PathSensitivity.RELATIVE)
    public List<FileCollection> getJavaFiles() {