import org.gradle.internal.UncheckedException; //导入依赖的package包/类
public static File getClasspathForClass(Class<?> targetClass) {
    URI location;
    try {
        CodeSource codeSource = targetClass.getProtectionDomain().getCodeSource();
        if (codeSource != null && codeSource.getLocation() != null) {
            location = codeSource.getLocation().toURI();
            if (location.getScheme().equals("file")) {
                return new File(location);
            }
        }
        if (targetClass.getClassLoader() != null) {
            String resourceName = targetClass.getName().replace('.', '/') + ".class";
            URL resource = targetClass.getClassLoader().getResource(resourceName);
            if (resource != null) {
                return getClasspathForResource(resource, resourceName);
            }
        }
        throw new GradleException(String.format("Cannot determine classpath for class %s.", targetClass.getName()));
    } catch (URISyntaxException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
@Override
public void send(String title, String message) {
    String isRunning = "\ntell application \"System Events\"\n"
        + "set isRunning to count of (every process whose bundle identifier is \"com.Growl.GrowlHelperApp\") > 0\n"
        + "end tell\n" + "return isRunning\n";
    try {
        Object value = engine.eval(isRunning);
        if (value.equals(0)) {
            throw new AnnouncerUnavailableException("Growl is not running.");
        }
        final File icon = iconProvider.getIcon(48, 48);
        String iconDef = icon != null ? "image from location ((POSIX file \"" + icon.getAbsolutePath() + "\") as string) as alias" : "";
        String script = "\ntell application id \"com.Growl.GrowlHelperApp\"\n"
            + "register as application \"Gradle\" all notifications {\"Build Notification\"} default notifications {\"Build Notification\"}\n"
            + "notify with name \"Build Notification\" title \"" + escape(title) + "\" description \"" + escape(message)
            + "\" application name \"Gradle\"" + iconDef
            + "\nend tell\n";
        engine.eval(script);
    } catch (ScriptException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
@Override
public void execute(final WorkerProcessContext workerProcessContext) {
    LOGGER.info("{} started executing tests.", workerProcessContext.getDisplayName());

    completed = new CountDownLatch(1);

    System.setProperty(WORKER_ID_SYS_PROPERTY, workerProcessContext.getWorkerId().toString());

    DefaultServiceRegistry testServices = new TestFrameworkServiceRegistry(workerProcessContext);
    startReceivingTests(workerProcessContext, testServices);

    try {
        try {
            completed.await();
        } catch (InterruptedException e) {
            throw new UncheckedException(e);
        }
    } finally {
        LOGGER.info("{} finished executing tests.", workerProcessContext.getDisplayName());
        // Clean out any security manager the tests might have installed
        System.setSecurityManager(null);
        testServices.close();
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
private static Stoppable toStoppable(final Object object) {
    if (object instanceof Stoppable) {
        return (Stoppable) object;
    }
    if (object instanceof Closeable) {
        final Closeable closeable = (Closeable) object;
        return new Stoppable() {
            @Override
            public String toString() {
                return closeable.toString();
            }

            public void stop() {
                try {
                    closeable.close();
                } catch (IOException e) {
                    throw UncheckedException.throwAsUncheckedException(e);
                }
            }
        };
    }
    return NO_OP_STOPPABLE;
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
public void stop() {
    Throwable failure = null;
    try {
        for (Stoppable element : elements) {
            try {
                element.stop();
            } catch (Throwable throwable) {
                if (failure == null) {
                    failure = throwable;
                } else {
                    LOGGER.error(String.format("Could not stop %s.", element), throwable);
                }
            }
        }
    } finally {
        elements.clear();
    }

    if (failure != null) {
        throw UncheckedException.throwAsUncheckedException(failure);
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
public static ClassPath getClasspath(ClassLoader classLoader) {
    final List<File> implementationClassPath = new ArrayList<File>();
    new ClassLoaderVisitor() {
        @Override
        public void visitClassPath(URL[] classPath) {
            for (URL url : classPath) {
                try {
                    implementationClassPath.add(new File(url.toURI()));
                } catch (URISyntaxException e) {
                    throw new UncheckedException(e);
                }
            }
        }
    }.visit(classLoader);
    return DefaultClassPath.of(implementationClassPath);
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
private DaemonClientConnection connectToCanceledDaemon(Collection<DaemonInfo> busyDaemons, ExplainingSpec<DaemonContext> constraint) {
    DaemonClientConnection connection = null;
    final Pair<Collection<DaemonInfo>, Collection<DaemonInfo>> canceledBusy = partitionByState(busyDaemons, Canceled);
    final Collection<DaemonInfo> compatibleCanceledDaemons = getCompatibleDaemons(canceledBusy.getLeft(), constraint);
    if (!compatibleCanceledDaemons.isEmpty()) {
        LOGGER.info(DaemonMessages.WAITING_ON_CANCELED);
        CountdownTimer timer = Timers.startTimer(CANCELED_WAIT_TIMEOUT);
        while (connection == null && !timer.hasExpired()) {
            try {
                sleep(200);
                connection = connectToIdleDaemon(daemonRegistry.getIdle(), constraint);
            } catch (InterruptedException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
    }
    return connection;
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
public void stop() {
    lifecycleLock.lock();
    try {
        if (!stopped) {
            try {
                disconnectableInput.close();
            } catch (IOException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }

            forwardingExecuter.stop();
            stopped = true;
        }
    } finally {
        lifecycleLock.unlock();
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
@Override
public DefaultManifest getEffectiveManifest() {
    ContainedVersionAnalyzer analyzer = analyzerFactory.create();
    DefaultManifest effectiveManifest = new DefaultManifest(null);
    try {
        setAnalyzerProperties(analyzer);
        Manifest osgiManifest = analyzer.calcManifest();
        java.util.jar.Attributes attributes = osgiManifest.getMainAttributes();
        for (Map.Entry<Object, Object> entry : attributes.entrySet()) {
            effectiveManifest.attributes(WrapUtil.toMap(entry.getKey().toString(), (String) entry.getValue()));
        }
        effectiveManifest.attributes(this.getAttributes());
        for (Map.Entry<String, Attributes> ent : getSections().entrySet()) {
            effectiveManifest.attributes(ent.getValue(), ent.getKey());
        }
        if (classesDir != null) {
            long mod = classesDir.lastModified();
            if (mod > 0) {
                effectiveManifest.getAttributes().put(Analyzer.BND_LASTMODIFIED, mod);
            }
        }
    } catch (Exception e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
    return getEffectiveManifestInternal(effectiveManifest);
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
private ZipOutputStream openJarOutputStream(File outputJar) {
    try {
        ZipOutputStream outputStream = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(outputJar), BUFFER_SIZE));
        outputStream.setLevel(0);
        return outputStream;
    } catch (IOException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
private void run() {
    ClassLoaderUtils.disableUrlConnectionCaching();
    final Thread thread = Thread.currentThread();
    final ClassLoader previousContextClassLoader = thread.getContextClassLoader();
    final ClassLoader classLoader = new URLClassLoader(new DefaultClassPath(runSpec.getClasspath()).getAsURLArray(), null);
    thread.setContextClassLoader(classLoader);
    try {
        Object buildDocHandler = runAdapter.getBuildDocHandler(classLoader, runSpec.getClasspath());
        Object buildLink = runAdapter.getBuildLink(classLoader, runSpec.getProjectPath(), runSpec.getApplicationJar(), runSpec.getChangingClasspath(), runSpec.getAssetsJar(), runSpec.getAssetsDirs());
        runAdapter.runDevHttpServer(classLoader, classLoader, buildLink, buildDocHandler, runSpec.getHttpPort());
    } catch (Exception e) {
        throw UncheckedException.throwAsUncheckedException(e);
    } finally {
        thread.setContextClassLoader(previousContextClassLoader);
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
private static Map<String, List<String>> readConfigMappings(DependencyDescriptor dependencyDescriptor) {
    if (dependencyDescriptor instanceof DefaultDependencyDescriptor) {
        try {
            return (Map<String, List<String>>) DEPENDENCY_CONFIG_FIELD.get(dependencyDescriptor);
        } catch (IllegalAccessException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    String[] modConfs = dependencyDescriptor.getModuleConfigurations();
    Map<String, List<String>> results = Maps.newLinkedHashMap();
    for (String modConf : modConfs) {
        results.put(modConf, Arrays.asList(dependencyDescriptor.getDependencyConfigurations(modConfs)));
    }
    return results;
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
public LocallyAvailableResource putModuleDescriptor(ModuleComponentAtRepositoryKey component, final ModuleComponentResolveMetadata metadata) {
    String filePath = getFilePath(component);
    return metaDataStore.add(filePath, new Action<File>() {
        public void execute(File moduleDescriptorFile) {
            try {
                KryoBackedEncoder encoder = new KryoBackedEncoder(new FileOutputStream(moduleDescriptorFile));
                try {
                    moduleMetadataSerializer.write(encoder, metadata);
                } finally {
                    encoder.close();
                }
            } catch (Exception e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
    });
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
public void stop() {
    lock.lock();
    try {
        stopped = true;
        while (!executing.isEmpty()) {
            try {
                condition.await();
            } catch (InterruptedException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
        this.connection = null;
    } finally {
        lock.unlock();
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
@Override
public Object getBuildDocHandler(ClassLoader docsClassLoader, Iterable<File> classpath) throws NoSuchMethodException, ClassNotFoundException, IOException, IllegalAccessException {
    Class<?> docHandlerFactoryClass = getDocHandlerFactoryClass(docsClassLoader);
    Method docHandlerFactoryMethod = docHandlerFactoryClass.getMethod("fromJar", JarFile.class, String.class);
    JarFile documentationJar = findDocumentationJar(classpath);
    try {
        return docHandlerFactoryMethod.invoke(null, documentationJar, "play/docs/content");
    } catch (InvocationTargetException e) {
        throw UncheckedException.unwrapAndRethrow(e);
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
@Override
public void execute(WorkerProcessContext context) {
    stop = new CountDownLatch(1);
    final PlayRunWorkerClientProtocol clientProtocol = context.getServerConnection().addOutgoing(PlayRunWorkerClientProtocol.class);
    context.getServerConnection().addIncoming(PlayRunWorkerServerProtocol.class, this);
    context.getServerConnection().connect();
    final PlayAppLifecycleUpdate result = startServer();
    try {
        clientProtocol.update(result);
        stop.await();
    } catch (InterruptedException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    } finally {
        clientProtocol.update(PlayAppLifecycleUpdate.stopped());
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
public void dispatch(final T message) {
    lock.lock();
    try {
        while (state != State.Stopped && queue.size() >= maxQueueSize) {
            try {
                condition.await();
            } catch (InterruptedException e) {
                throw new UncheckedException(e);
            }
        }
        if (state == State.Stopped) {
            throw new IllegalStateException("Cannot dispatch message, as this message dispatch has been stopped. Message: " + message);
        }
        queue.add(message);
        condition.signalAll();
    } finally {
        lock.unlock();
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
/**
 * Stops accepting new messages, and blocks until all queued messages have been dispatched.
 */
public void stop() {
    lock.lock();
    try {
        setState(State.Stopped);
        while (dispatchers > 0) {
            condition.await();
        }

        if (!queue.isEmpty()) {
            throw new IllegalStateException(
                    "Cannot wait for messages to be dispatched, as there are no dispatch threads running.");
        }
    } catch (InterruptedException e) {
        throw new UncheckedException(e);
    } finally {
        lock.unlock();
    }
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
public SocketConnection(SocketChannel socket, MessageSerializer streamSerializer, StatefulSerializer<T> messageSerializer) {
    this.socket = socket;
    try {
        // NOTE: we use non-blocking IO as there is no reliable way when using blocking IO to shutdown reads while
        // keeping writes active. For example, Socket.shutdownInput() does not work on Windows.
        socket.configureBlocking(false);
        outstr = new SocketOutputStream(socket);
        instr = new SocketInputStream(socket);
    } catch (IOException e) {
        throw UncheckedException.throwAsUncheckedException(e);
    }
    InetSocketAddress localSocketAddress = (InetSocketAddress) socket.socket().getLocalSocketAddress();
    localAddress = new SocketInetAddress(localSocketAddress.getAddress(), localSocketAddress.getPort());
    InetSocketAddress remoteSocketAddress = (InetSocketAddress) socket.socket().getRemoteSocketAddress();
    remoteAddress = new SocketInetAddress(remoteSocketAddress.getAddress(), remoteSocketAddress.getPort());
    objectReader = messageSerializer.newReader(streamSerializer.newDecoder(instr));
    encoder = streamSerializer.newEncoder(outstr);
    objectWriter = messageSerializer.newWriter(encoder);
}
 

import org.gradle.internal.UncheckedException; //导入依赖的package包/类
private void remapClasses(File scriptCacheDir, File relocalizedDir, RemappingScriptSource source) {
    ScriptSource origin = source.getSource();
    String className = origin.getClassName();
    if (!relocalizedDir.exists()) {
        relocalizedDir.mkdir();
    }
    File[] files = scriptCacheDir.listFiles();
    if (files != null) {
        for (File file : files) {
            String renamed = file.getName();
            if (renamed.startsWith(RemappingScriptSource.MAPPED_SCRIPT)) {
                renamed = className + renamed.substring(RemappingScriptSource.MAPPED_SCRIPT.length());
            }
            ClassWriter cv = new ClassWriter(0);
            BuildScriptRemapper remapper = new BuildScriptRemapper(cv, origin);
            try {
                ClassReader cr = new ClassReader(Files.toByteArray(file));
                cr.accept(remapper, 0);
                Files.write(cv.toByteArray(), new File(relocalizedDir, renamed));
            } catch (IOException ex) {
                throw UncheckedException.throwAsUncheckedException(ex);
            }
        }
    }
}