message.resetStyle().append(resource.getResourceName());

        out.println(message.toString());
    }

    @Override
    public void transferCorrupted(TransferEvent event) throws TransferCancelledException {
        TransferResource resource = event.getResource();
        // TODO This needs to be colorized

 */
public class GradleWorkerMain {
    public void run() throws Exception {
        DataInputStream instr = new DataInputStream(new EncodedStream.EncodedInput(System.in));

        // Read shared packages
        int sharedPackagesCount = instr.readInt();

        message.append(resource.getRepositoryUrl()).append(resource.getResourceName());

        out.info(message.toString());
    }

    @Override
    public void transferCorrupted(TransferEvent event) throws TransferCancelledException {
        TransferResource resource = event.getResource();
        out.warn(
                "{} from {} for {}{}",
                event.getException().getMessage(),

                        System.exit(1);
                    }
                }

                private static void runHelp(File projectLocation, String gradleVersion, File javaHome, File gradleUserHome) throws Exception {
                    GradleConnector connector = GradleConnector.newConnector();
                    connector.useGradleVersion(gradleVersion);

                    ProjectConnection connection = null;

    }

    @TargetGradleVersion('>=3.0 <5.1')
    def "throws UnsupportedMethodException for task origin when target version does not support it"() {
        when:
        runBuild('tasks')

        and:
        task(':tasks').originPlugin

        then:
        def e = thrown(UnsupportedMethodException)

            super(distribution, testDirectoryProvider)
            this.testKitDir = testKitDir
            this.buildContext = buildContext
        }

        @Override
        void assertCanExecute() throws AssertionError {
        }

        @Override
        protected ExecutionResult doRun() {
            def runnerResult = createRunner().build()

        return DISABLE_COUNT.get() == 0;
    }

    public interface ThrowingFactory<T, E extends Exception> {
        T create() throws E;
    }

    public interface ThrowingRunnable<E extends Exception> {
        void run() throws E;
    }

    /**
     * Turns a {@link ThrowingFactory} into a {@link Factory}.

    @Override
    public <T> T get(Class<T> serviceType) throws UnknownServiceException, ServiceLookupException {
        return serviceType.cast(get((Type) serviceType));
    }

    @Override
    public Object get(Type serviceType) throws UnknownServiceException, ServiceLookupException {
        Object instance = find(serviceType);
        if (instance == null) {

            sb.append("</tr>");
            sb.append(LS);
        }
        sb.append("</table>");
        return sb.toString();
    }

    @Test
    void testOptionsAsHtml() throws IOException {
        Path options = Paths.get("target/test-classes/options.html");
        Files.writeString(options, getOptionsAsHtml(), StandardCharsets.UTF_8);
    }

    }

    @TargetGradleVersion('>=3.0 <5.1')
    def "throws UnsupportedMethodException for task dependencies when target version does not support it"() {
        when:
        runBuild('tasks')

        and:
        task(':tasks').dependencies

        then:
        def e = thrown(UnsupportedMethodException)