then:
        succeeds("echo")
        executedAndNotSkipped(":echo")
        output.contains("text: original")
        when: "symlink is deleted"
        symlink.delete()
        then:
        buildTriggeredAndSucceeded()
        executedAndNotSkipped(":echo")
        output.contains("text: missing")
        when: "symlink is created"

}

// DestroySet is part of interface.  It deletes both the entries and the set itself.
func (f *FakeIPSet) DestroySet(set string) error {
	delete(f.Sets, set)
	delete(f.Entries, set)
	return nil
}

// DestroyAllSets is part of interface.
func (f *FakeIPSet) DestroyAllSets() error {
	f.Sets = nil
	f.Entries = nil
	return nil
}

// CreateSet is part of interface.

        !result.didWork
    }

    def deletes() {
        def fileToBeDeleted = tmpDir.file("file")
        def fileCollection = Stub(FileCollectionInternal)
        fileCollectionFactory.resolving(["file"] as Object[]) >> fileCollection
        fileCollection.iterator() >> [fileToBeDeleted].iterator()
        fileToBeDeleted.touch()

        expect:
        fileOperations.delete('file') == true

    private final Deleter deleter;
    private final OutputChangeListener outputChangeListener;
    private final Step<? super C, ? extends R> delegate;

    public RemovePreviousOutputsStep(
        Deleter deleter,
        OutputChangeListener outputChangeListener,
        Step<? super C, ? extends R> delegate
    ) {
        this.deleter = deleter;
        this.outputChangeListener = outputChangeListener;

import org.gradle.internal.file.Deleter;
import org.gradle.work.FileChange;

import java.util.Set;
import java.util.stream.Collectors;

public class GroovyRecompilationSpecProvider extends AbstractRecompilationSpecProvider {

    private static final Set<String> SUPPORTED_FILE_EXTENSIONS = ImmutableSet.of(".java", ".groovy");

    public GroovyRecompilationSpecProvider(
        Deleter deleter,

	utilnet "k8s.io/utils/net"
)

// Interface for dealing with conntrack
type Interface interface {
	// ClearEntriesForIP deletes conntrack entries for connections of the given
	// protocol, to the given IP.
	ClearEntriesForIP(ip string, protocol v1.Protocol) error

	// ClearEntriesForPort deletes conntrack entries for connections of the given
	// protocol and IP family, to the given port.

	steps := []struct {
		added        *v1.ConfigMap
		updated      *v1.ConfigMap
		deleted      *v1.ConfigMap
		expectCalled bool
		expectCM     *v1.ConfigMap
	}{
		{added: cm2},
		{added: cm, expectCalled: true, expectCM: cm},
		{updated: cm},
		{updated: cm1, expectCalled: true, expectCM: cm1},
		{deleted: cm1, expectCalled: true},
		{deleted: cm2},
	}

	stop := make(chan struct{})

            import org.gradle.api.internal.tasks.TaskPropertyUtils

            task clean(type: Delete) {
                delete 'foo'
                delete file('bar')
                delete files('baz')


                doLast {
                    def destroyablePaths = []
                    def propertyWalker = services.get(PropertyWalker)

	}
}

// DeleteBucket deletes monitoring the 'bucket'
func (m *Monitor) DeleteBucket(bucket string) {
	m.tlock.Lock()
	for opts := range m.bucketsThrottle {
		if opts.Name == bucket {
			delete(m.bucketsThrottle, opts)
		}
	}
	m.tlock.Unlock()

	m.mlock.Lock()
	for opts := range m.bucketsMeasurement {
		if opts.Name == bucket {
			delete(m.bucketsMeasurement, opts)
		}
	}

				g.Expect(err).Should(BeNil())
			case step.updated != nil:
				_, err := cms.Update(context.TODO(), step.updated, metav1.UpdateOptions{})
				g.Expect(err).Should(BeNil())
			case step.deleted != nil:
				g.Expect(cms.Delete(context.TODO(), step.deleted.Name, metav1.DeleteOptions{})).
					Should(Succeed())
			}

			g.Eventually(func() *Config {
				mu.Lock()
				defer mu.Unlock()
				return newConfig