import static org.gradle.internal.io.IoFunction.wrap

class IoFunctionTest extends AbstractIoTest {

    def "executed when it doesn't throw"() {
        expect:
        wrap({ String t -> "wrapped:$t" }).apply("lajos") == "wrapped:lajos"
    }

    @Override
    protected void executeWithException(Throwable exception) {
        wrap({ String t ->
            assert t == "lajos"
            throw exception

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.exception;

/**
 * Wrapped InterruptedException.
 *
 * @author shinsuke
 *
 */
public class InterruptedRuntimeException extends RuntimeException {

    private static final long serialVersionUID = 1L;

   * running will have the given name.
   *
   * @param callable The callable to wrap
   * @param nameSupplier The supplier of thread names, {@link Supplier#get get} will be called once
   *     for each invocation of the wrapped callable.
   */
  @J2ktIncompatible
  @GwtIncompatible // threads
  static <T extends @Nullable Object> Callable<T> threadRenaming(
      Callable<T> callable, Supplier<String> nameSupplier) {

	// Functions that need frames <= StackBig can assume that neither
	// SP-framesize nor stackGuard-StackSmall will underflow, and thus use a
	// more efficient check. In order to ensure this, StackBig must be <= the
	// size of the unmapped space at zero.
	StackBig = 4096

            new RuntimeException("lajos"),
            new Error("lajos"),
            new UncheckedIOException(new IOException("lajos"))
        ]
        type = original.class
    }

    def "IOException is thrown wrapped in UncheckedIOException"() {
        def original = new IOException("lajos")
        when:
        executeWithException(original)
        then:
        def ex = thrown UncheckedIOException
        ex.cause === original

 * limitations under the License.
 */

package org.gradle.internal

import spock.lang.Specification

class ErroringActionTest extends Specification {

    def "checked exceptions are wrapped"() {
        when:
        new ErroringAction() {
            @Override
            void doExecute(Object thing) {
                throw new Exception()
            }
        }.execute("foo")

        then:

            [fromStringList(), "execute(command)", "", ""],
            [fromObjectList(), "execute(command)", "", ""],
            // Spread calls
            [fromString(), "execute(*[command])", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "execute(command as String)", "", ""],
        ]
    }

            [fromObjectList(), "ProcessGroovyMethods.execute(command)", "", ""],
            // Spread calls
            [fromString(), "ProcessGroovyMethods.execute(*[command])", "", ""],
            // type-wrapped arguments
            [fromGroovyString(), "ProcessGroovyMethods.execute(command as String)", "", ""],
        ]
    }

	klog.V(3).Infof("Setting up a downwardAPI volume %v for pod %v/%v at %v", b.volName, b.pod.Namespace, b.pod.Name, dir)
	// Wrap EmptyDir. Here we rely on the idempotency of the wrapped plugin to avoid repeatedly mounting
	wrapped, err := b.plugin.host.NewWrapperMounter(b.volName, wrappedVolumeSpec(), b.pod, *b.opts)
	if err != nil {

        where:
        type      | implementation
        "Closure" | { it }
        "Action"  |  new Action<String>() { @Override void execute(String s) {} }
    }

    def "correct implementation for closure wrapped in Action is tracked"() {
        given:
        def closure = { it }

        expect:
        ScriptSourceAwareImplementationResolver.unwrapBean(ConfigureUtil.configureUsing(closure)) == closure

        and: