* or output) cannot execute concurrently with a task that destroys this file. This is useful for tasks that
 * clean up after other tasks such as `clean`.</p>
 *
 * @since 4.0
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD})
public @interface Destroys {

        }
    }

    def "destroyer task with a dependency in another project followed by a producer task followed by a destroyer task are run in the correct order"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

        def cleanFoo = foo.task('cleanFoo').destroys('build/foo')
        def cleanBar = bar.task('cleanBar').destroys('build/bar').dependsOn(cleanFoo)

    def "producer task that finalizes a destroyer task will run after the destroyer even when ordered first (type: #type)"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

        def cleanFoo = foo.task('cleanFoo').destroys('build/foo')
        def cleanBar = bar.task('cleanBar').destroys('build/bar')

        taskMutator,
        TestFiles.fileCollectionFactory(testDir.testDirectory)
    )

    def "empty destroys by default"() {
        expect:
        taskDestroys.registeredFiles != null
        taskDestroys.registeredFiles.isEmpty()
    }

    def "can declare a file that a task destroys"() {
        when:
        taskDestroys.register("a")

        then:

/**
 * Represents the files or directories that a {@link org.gradle.api.Task} destroys (removes).
 *
 * @since 4.0
 */
@HasInternalProtocol
public interface TaskDestroyables {
    /**
     * Registers files or directories that this task destroys.
     *
     * @param paths The files or directories that will be destroyed. The given paths are evaluated as per {@link org.gradle.api.Project#files(Object...)}.
     *

            return this
        }

        TaskFixture mustRunAfter(TaskFixture task) {
            mustRunAfter.add(task)
            return this
        }

        TaskFixture destroys(String path) {
            destroys.add(path)
            return this
        }

        TaskFixture outputs(String path) {
            return produces(path, ProductionType.OUTPUT)
        }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.tasks.properties.annotations;

import org.gradle.api.tasks.Destroys;
import org.gradle.internal.execution.model.annotations.ModifierAnnotationCategory;
import org.gradle.internal.properties.PropertyValue;
import org.gradle.internal.properties.PropertyVisitor;

    operator.write(80, buffer, buffer.size)
    assertThat(snapshot()).isEqualTo(
      (
        "" +
          "god creates dinosaurs. " +
          "god destroys dinosaurs. " +
          "god creates man. " +
          "man destroys god. " +
          "man creates dinosaurs. "
      ).encodeUtf8(),
    )
  }

  @Test
  fun multipleOperatorsShareOneFile() {
    val operatorA =

            class DestroyerBean {
                @Destroys File destroyedFile
            }

            task destroy(type: MyDestroyer) {
                bean = new DestroyerBean(
                    destroyedFile: file("\$buildDir/destroyed")
                )
            }
            task printMetadata(type: PrintInputsAndOutputs) {
                task = destroy
            }
        """

        when:

import org.gradle.api.tasks.CacheableTask;
import org.gradle.api.tasks.Classpath;
import org.gradle.api.tasks.CompileClasspath;
import org.gradle.api.tasks.Console;
import org.gradle.api.tasks.Destroys;
import org.gradle.api.tasks.IgnoreEmptyDirectories;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.InputDirectory;
import org.gradle.api.tasks.InputFile;
import org.gradle.api.tasks.InputFiles;