// Only the addresses of the current family are returned.
	// IPv6 link-local and loopback addresses are excluded.
	GetAllLocalAddresses() (sets.Set[string], error)
	// GetLocalAddresses return all local addresses for an interface.
	// Only the addresses of the current family are returned.
	// IPv6 link-local and loopback addresses are excluded.
	GetLocalAddresses(dev string) (sets.Set[string], error)

    public void setPath(String path) {
        relativePath = RelativePath.parse(getRelativePath().isFile(), path);
    }

    boolean isExcluded() {
        return excluded;
    }

    @Override
    public void exclude() {
        excluded = true;
    }

    @Override
    @Deprecated
    public void setMode(int mode) {
        DeprecationLogger.deprecateMethod(CopyProcessingSpec.class, "setMode()")

# Test that GOPATH/pkg/mod is excluded
env GO111MODULE=off
! go list mod/foo
stderr 'disallowed import path'

-- mod/foo/foo.go --

// run

//go:build !wasm

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// wasm is excluded because the compiler chatter about register abi pragma ends up
// on stdout, and causes the expected output to not match.

package main

import "fmt"

type i5f5 struct {
	a, b          int16
	c, d, e       int32

	var (
		added    = make(map[module.Version]bool)
		rdeps    = make(map[module.Version][]module.Version)
		excluded = make(map[module.Version]bool)
	)
	var exclude func(module.Version)
	exclude = func(m module.Version) {
		if excluded[m] {
			return
		}
		excluded[m] = true
		for _, p := range rdeps[m] {
			exclude(p)
		}
	}
	var add func(module.Version)
	add = func(m module.Version) {
		if added[m] {

				t.Skipf("skipping: GOROOT/test not present")
			}
		}
		t.Fatal(err)
	}

	excluded := make(map[string]bool)
	for _, filename := range ignore {
		excluded[filename] = true
	}

	for _, f := range files {
		// filter directory contents
		if f.IsDir() || !strings.HasSuffix(f.Name(), ".go") || excluded[f.Name()] {
			continue
		}

		// get per-file instructions
		expectErrors := false

labels.createdTime=Created Time
labels.depth=Depth
labels.excludedPaths=Excluded Paths For Crawling
labels.excludedUrls=Excluded URLs For Crawling
labels.excludedDocPaths=Excluded Paths For Indexing
labels.excludedDocUrls=Excluded URLs For Indexing
labels.hostname=Hostname
labels.id=ID
labels.includedPaths=Included Paths For Crawling
labels.includedUrls=Included URLs For Crawling
labels.includedDocPaths=Included Paths For Indexing

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !race

package regexp

import (
	"testing"
)

// This test is excluded when running under the race detector because
// it is a very expensive test and takes too long.
func TestRE2Exhaustive(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping TestRE2Exhaustive during short test")
	}

env GOOS=linux
env GOARCH=amd64
go list all

# go list all should work with GOOS=darwin, but it used to fail because
# in the absence of //go:build support, p looked like it needed q
# (p_test.go was not properly excluded), and q was Linux-only.
#
# Also testing with r and s that +build lines keep working.
env GOOS=darwin
go list all

-- go.mod --
go 1.17
module m

-- p/p.go --
package p

-- p/p_test.go --

import java.io.File


/**
 * Defines specific configuration inputs that should not be included in the configuration cache fingerprint.
 */
@ServiceScope(Scope.BuildTree::class)
interface IgnoredConfigurationInputs {
    /**
     * Checks if the [file] should be excluded from the configuration inputs fingerprint if it participates
     * in file system checks, such as [File.exists], [File.isFile] etc.