public Object invoke(Object target, @Nullable Object... args) {
        try {
            return method.bindTo(target).invokeWithArguments(args);
        } catch (Throwable e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

        try {
            while (outOfDate) {
                try {
                    upToDate.await();
                } catch (InterruptedException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
            return delegate.status();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void outOfDate() {

            try {
                return (Class<?>) type.getMethod("generatedFrom").invoke(null);
            } catch (Exception e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
        return type;
    }

    public static Class<?> unpackType(Object object) {
        if (object instanceof GeneratedSubclass) {

            throw new AssertionError("Timeout waiting for operation to complete.")
        }
    }

    def failWithFailure() {
        if (failure) {
            throw UncheckedException.throwAsUncheckedException(BlockingResultHandler.attachCallerThreadStackTrace(failure))
        }
    }

    def assertNoFailure() {
        if (failure == null) {
            return true
        } else {
            throw failure

        uri("https://pgp.mit.edu")
    );

    private static URI uri(String uri) {
        try {
            return new URI(uri);
        } catch (URISyntaxException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    public static List<URI> getOrDefaults(List<URI> uris) {
        if (uris.isEmpty()) {
            return DEFAULT_KEYSERVERS;
        }
        return uris;
    }

            while (!finished && pending == null) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
            if (pending != null) {
                UserInput result = pending;
                pending = null;
                return result;
            }

        try {
            return new URI("file", "", path.toURI().getPath(), null, null).toASCIIString();
        } catch (URISyntaxException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

            return (TestClassProcessor) constructor.newInstance(spec, idGenerator, actorFactory, clock);
        } catch (Exception e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

import org.gradle.internal.time.Timer;

import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import static org.gradle.internal.UncheckedException.throwAsUncheckedException;

/**
 * Serializes the transient parts of the resolved configuration results.
 */
public class TransientConfigurationResultsBuilder {

            // Wait for a short while to check for unexpected requests
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
            doReleaseAction(handler, yetToBeReceived);
        });
    }

    abstract void doReleaseAction(BlockingHttpServer.BlockingHandler handler, int yetToBeReceived);