env GO111MODULE=on
[!symlink] skip

cd m
symlink symlink -> ../outside

cp go.mod go.mod.orig

# Issue 35941: suppress symlink warnings when running 'go mod tidy'.
# 'go mod tidy' should not scan packages in symlinked subdirectories.
go mod tidy
! stderr 'warning: ignoring symlink'
cmp go.mod go.mod.orig

! go build ./symlink

        expect:
        fs.chmod(tmpDir.createFile("someFile"), 0644)
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "can create symlink on platforms that support symlinks"() {
        def target = tmpDir.createFile("target.txt")
        def link = tmpDir.file("link.txt")

        when:
        fs.createSymbolicLink(link, target)

        then:

import java.nio.file.Files
import java.nio.file.StandardCopyOption

@Requires(UnitTestPreconditions.Symlinks)
class IncrementalBuildSymlinkHandlingIntegrationTest extends AbstractIntegrationSpec implements ValidationMessageChecker {
    def setup() {
        expectReindentedValidationMessage()

        // Must run on isolated daemons so that symlink data can be properly cleaned up between builds
        executer.requireDaemon()

	// Evaluate all symlinks here once for all subsequent functions.
	newVolumePath, err := filepath.EvalSymlinks(subpath.VolumePath)
	if err != nil {
		return "", fmt.Errorf("error resolving symlinks in %q: %v", subpath.VolumePath, err)
	}
	newPath, err := filepath.EvalSymlinks(subpath.Path)
	if err != nil {
		return "", fmt.Errorf("error resolving symlinks in %q: %v", subpath.Path, err)
	}

        strategy << allFingerprintingStrategies
        strategyName = getStrategyName(strategy)
    }

    def "non-root broken symlink is fingerprinted as missing for #strategyName"() {
        given:
        def root = file('root')
        root.mkdirs()
        def brokenSymlink = root.file('broken-symlink')
        brokenSymlink.createLink(file('non-existing'))

        when:

			t.Fatalf("Unable to create a file, %s", err)
		}
		// Symlink will not be added to entries.
		if err := os.Symlink(filepath.Join(dir, name1), filepath.Join(dir, name2)); err != nil {
			t.Fatalf("Unable to create a symlink, %s", err)
		}
		// Add to entries.
		entries = append(entries, name1)
		// Symlinks are preserved for regular files
		entries = append(entries, name2)
	}

	return nil
}

// SafeMakeDir makes sure that the created directory does not escape given base directory mis-using symlinks.
func (sp *subpath) SafeMakeDir(subdir string, base string, perm os.FileMode) error {
	realBase, err := evalSymlink(base)
	if err != nil {
		return fmt.Errorf("error resolving symlinks in %s: %s", base, err)
	}

	realFullPath := filepath.Join(realBase, subdir)

# Since we do preserve $PWD (or set it appropriately) for commands, and we do
# not resolve symlinks unnecessarily, referring to the contents of the unsafe
# directory via a safe symlink should be ok, and should not inject the data from
# the symlink target path.

[!symlink] stop 'remainder of test checks symlink behavior'
[short] stop 'links and runs binaries'

symlink $WORK${/}link -> $DIR

[cgo] go run $WORK${/}link${/}main.go

     * hierarchy containing a symlink, as we can't be sure if the snapshot would still be valid of
     * the relocated link.
     *
     * If performance around symlinks becomes more important, we can improve this in multiple ways:
     * - keep symlinks that don't point outside the relocated snapshot hierarchy,
     * - re-snapshot relocated locations pointed to by snapshots,

			}
			perm = info.Mode() & os.ModePerm
		}

		// Always copy directories (don't symlink them).
		// If we add a file in the overlay, we don't want to add it in the original.
		if info.IsDir() {
			return os.MkdirAll(dstPath, perm|0200)
		}

		// If the OS supports symlinks, use them instead of copying bytes.
		if err := os.Symlink(srcPath, dstPath); err == nil {
			return nil
		}

		// Otherwise, copy the bytes.