}

    def duplicatesExcludedByDefaultConfiguration() {
        given:
        files 'path/file1.txt', 'path/file2.txt', 'path/file1.txt'
        actions {}
        copySpecResolver.duplicatesStrategy >> DuplicatesStrategy.EXCLUDE

        when:
        visit()

        then:
        1 * delegateAction.processFile({ it.relativePath.pathString == '/root/path/file1.txt' })

    }

    @Override
    public void setDuplicatesStrategy(DuplicatesStrategy strategy) {
        this.duplicatesStrategy = strategy;
        this.defaultDuplicatesStrategy = strategy == DuplicatesStrategy.INHERIT;
    }

    @Override
    public DuplicatesStrategy getDuplicatesStrategy() {
        return this.duplicatesStrategy;
    }

    @Override
    public boolean isDefaultDuplicatesStrategy() {

            val destPath = readNullableString()
            val sourceFiles = read() as FileCollection
            val patterns = read() as PatternSet
            val duplicatesStrategy = readEnum<DuplicatesStrategy>()
            val includeEmptyDirs = readBoolean()
            val isCaseSensitive = readBoolean()
            val filteringCharset = readString()
            val dirMode = readNullableSmallInt()

        }

        @Override
        public DuplicatesStrategy getDuplicatesStrategy() {
            if (duplicatesStrategy != DuplicatesStrategy.INHERIT) {
                return duplicatesStrategy;
            }
            if (parentResolver != null) {
                return parentResolver.getDuplicatesStrategy();
            }
            return DuplicatesStrategy.INCLUDE;
        }

        @Override

        "includeEmptyDirs"   | "includeEmptyDirs = false"                        | "includeEmptyDirs = true"
        "duplicatesStrategy" | "duplicatesStrategy = DuplicatesStrategy.EXCLUDE" | "duplicatesStrategy = DuplicatesStrategy.INCLUDE"
        "dirPermissions"     | "dirPermissions { unix(\"0700\") }"               | "dirPermissions { unix(\"0755\") }"

                        failWithIncorrectDuplicatesStrategySetup(relativePath);
                    }
                    if (strategy == DuplicatesStrategy.EXCLUDE) {
                        return;
                    } else if (strategy == DuplicatesStrategy.FAIL) {

            </tr>
            <tr>
                <td>includeEmptyDirs</td>
                <td><literal>true</literal></td>
            </tr>
            <tr>
                <td>duplicatesStrategy</td>
                <td><literal>DuplicatesStrategy.INHERIT</literal></td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>

     */
    void setDuplicatesStrategy(DuplicatesStrategy strategy);

    /**
     * The strategy to use if there is already a file at this file's destination.
     * <p>
     * The value can be set with a case-insensitive string of the enum value (e.g. {@code 'exclude'} for {@link DuplicatesStrategy#EXCLUDE}).
     *
     * @see DuplicatesStrategy
     * @return the strategy to use for this file.
     */

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.internal.file.copy;

import org.gradle.api.file.DuplicatesStrategy;
import org.gradle.api.internal.file.FileCollectionFactory;
import org.gradle.api.model.ObjectFactory;
import org.gradle.api.tasks.util.PatternSet;
import org.gradle.internal.Factory;

        given:
        duplicateEntriesInArchive(taskName, taskType, fileExtension)

        buildFile << """
            ${taskName} {
                duplicatesStrategy = DuplicatesStrategy.EXCLUDE
            }
        """

        when:
        succeeds taskName

        then:
        archive(file("build/test.${fileExtension}")).content('test.txt') == "from dir2"