this.suspend = suspend;
    }

    public String getAddress(){
        String port = Integer.toString(this.port);
        return isNullOrEmpty(host) ? port : host + ":" + port;
    }

    public void copyTo(JavaDebugOptionsInternal opts) {
        opts.enabled = enabled;
        opts.suspend = suspend;
        opts.server = server;
        opts.port = port;
        opts.host = host;
    }

   *       one with {@link CharSequence#charAt(int)}.
   *   <li>use {@link Appendable#append(CharSequence)} in {@link #copyTo(Appendable)} and {@link
   *       #copyTo(CharSink)}. We know this is correct since strings are immutable and so the length
   *       can't change, and it is faster because many writers and appendables are optimized for

    }

    @Override
    public org.gradle.api.artifacts.ClientModule copy() {
        DefaultClientModule copiedClientModule = new DefaultClientModule(getGroup(), getName(), getVersion(), getTargetConfiguration());
        copyTo(copiedClientModule);
        for (ModuleDependency dependency : dependencies) {
            copiedClientModule.addDependency(dependency.copy());
        }
        return copiedClientModule;
    }

    @Override

        def copy = file("other")

        given:
        run("work")
        run("work")
        result.assertTasksSkipped(":work")

        when:
        inFile.copyTo(copy)
        inFile.delete()
        inFile.createLink(copy)
        run("work")

        /*
         * This documents the current behavior, which is optimizing

                outputFile.parentFile.mkdirs()
                zipFile.getInputStream(entry).use { input ->
                    outputFile.outputStream().use { output ->
                        input.copyTo(output)
                    }
                }
            }
        }
    }

    private
    fun ZipEntry.shouldInclude(): Boolean {
        if (name.endsWith(".class")) {

            }

            File targetFile = tempFileProvider.createTemporaryFile("fileCollection", ".txt", "resource");
            try {
                Files.asCharSource(fileCollection.getSingleFile(), charset).copyTo(Files.asCharSink(targetFile, targetCharsetObj));
            } catch (IOException e) {
                throw new ResourceException("Could not write " + getDisplayName() + " content to " + targetFile + ".", e);
            }

            </tr>
            <tr>
                <td>args</td>
            </tr>
            <tr>
                <td>classpath</td>
            </tr>
            <tr>
                <td>copyTo</td>
            </tr>
            <tr>
                <td>executable</td>
            </tr>
            <tr>
                <td>workingDir</td>
            </tr>
            <tr>

        // and the type to "jar" by default
        artifact.setName(getName());
        artifact.setType("jar");
        return artifact;
    }

    protected void copyTo(AbstractModuleDependency target) {
        super.copyTo(target);
        target.setArtifacts(new LinkedHashSet<>(getArtifacts()));
        target.setExcludeRuleContainer(new DefaultExcludeRuleContainer(getExcludeRules()));

        }

        @Override
        void setBytes(byte[] bytes) {
            file.bytes = bytes
        }

        @Override
        void copyBytesTo(TestFile file) {
            this.file.copyTo(file)
        }
    }

    public File getFile() {
        if (file == null) {
            file = new File(expandedDir, safeEntryName());
            if (!file.exists()) {
                GFileUtils.mkdirs(file.getParentFile());
                copyTo(file);
            }
        }
        return file;
    }

    @Override
    public RelativePath getRelativePath() {
        return new RelativePath(!getArchiveEntry().isDirectory(), safeEntryName().split("/"));