if filepath.Ext(filename) != ".go" {
		return nil, nil
	}

	// Clean filenames returned by src.Pos.SymFilename()
	// or src.PosBase.SymFilename() removing
	// the leading src.FileSymPrefix.
	filename = strings.TrimPrefix(filename, src.FileSymPrefix)

	// Expand literal "$GOROOT" rewritten by obj.AbsFile()
	filename = filepath.Clean(os.ExpandEnv(filename))

	var cf *CachedFile
	var e *list.Element

				VersionedKind:      examplev1.SchemeGroupVersion.WithKind("Pod"),
				Dirty:              true,
			},
		},
		{
			Name: "clean, typed",
			Attrs: &VersionedAttributes{
				Attributes: attrs(
					&example.Pod{ObjectMeta: metav1.ObjectMeta{Name: "newpod"}},
					&example.Pod{ObjectMeta: metav1.ObjectMeta{Name: "oldpod"}},
				),

// Store sets the value for a key.
func (m *Map) Store(key, value any) {
	_, _ = m.Swap(key, value)
}

// Clear deletes all the entries, resulting in an empty Map.
func (m *Map) Clear() {
	read := m.loadReadOnly()
	if len(read.m) == 0 && !read.amended {
		// Avoid allocating a new readOnly when the map is already clear.
		return
	}

	m.mu.Lock()
	defer m.mu.Unlock()

	read = m.loadReadOnly()

		if err != nil {
			return err
		}
	}
	if err = m.cleanupOrphanDeviceFiles(); err != nil {
		// V(4) for not so serious error
		klog.V(4).Infof("Failed to clean up block volume directory %s", err)
	}

	return nil
}

// Clean up any orphan files / directories when a block volume is being unstaged.
// At this point we can be sure that there is no pod using the volume and all
// files are indeed orphaned.

	$(eval VERSION := $(shell git describe --tags --abbrev=0).hotfix.$(shell git rev-parse --short HEAD))

hotfix: hotfix-vars clean install ## builds minio binary with hotfix tags
	@wget -q -c https://github.com/minio/pkger/releases/download/v2.2.9/pkger_2.2.9_linux_amd64.deb

        expect:
        // Start the action, which leaves a daemon worker process running after execution is complete.
        succeeds("runAction")
        // Now, while the worker is still running, clean the project build files.
        succeeds("clean")
    }

    def "can use worker action class that uses external dependencies in #isolationMode"() {

        given:
        file('ext-lib/settings.gradle') << "rootProject.name = 'ext'"

        given:
        coordinator.stop()

        when:
        def result = coordinator.awaitStop()

        then:
        stopped
        result == DaemonStopState.Clean
    }

    def "runs actions when command is run"() {
        Runnable command = Mock()

        when:
        coordinator.runCommand(command, "command")

        then:
        1 * onStartCommand.run()

    def "setup"() {
        settingsFile << "rootProject.name = 'test'"
        buildFile << app.pluginScript
        buildFile << app.extraConfiguration
    }

    @ToBeFixedForConfigurationCache
    def "clean build with PCH does not fail"() {
        given:
        writeStandardSourceFiles()

        when:
        buildFile << preCompiledHeaderComponent()

        then:
        args("--info")

type testSocket struct {
	path     string
	endpoint string
}

// newEndpoint constructs a unique name for a Linux Abstract Socket to be used in a test.
// This package uses Linux Domain Sockets to remove the need for clean-up of socket files.
func newEndpoint() *testSocket {
	p := fmt.Sprintf("@%s.sock", uuid.NewUUID())

	return &testSocket{
		path:     p,
		endpoint: fmt.Sprintf("unix:///%s", p),
	}
}

        then:
        executedAndNotSkipped(taskPath, ':copy1', ':copy2')
        targetFile1.assertIsFile()
        targetFile2.assertIsFile()
    }

    @NotYetImplemented
    // We don't clean anything which is not safe to delete
    def "tasks have output directories outside of build directory"() {
        given:
        def sourceFile1 = file('source/source1.txt')
        sourceFile1 << 'a'