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

package org.gradle.internal.buildtree;

/**
 * Performs any initial setup that needs to happen to a build tree work graph prior to scheduling the requested tasks.
 */
public interface BuildTreeWorkGraphPreparer {
    void prepareToScheduleTasks(BuildTreeWorkGraph.Builder workGraph);

**To Reproduce**
Steps to reproduce the behavior:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
A clear and concise description of what you expected to happen.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Environment (please complete the following information):**
 - OS: [e.g. Windows 10]
 - Version [e.g. 13.5.0]

import "internal/cpu"

const MaxBruteForce = 64

func init() {
	// Note: we're kind of lucky that this flag is available at this point.
	// The runtime sets HasVX when processing auxv records, and that happens
	// to happen *before* running the init functions of packages that
	// the runtime depends on.
	// TODO: it would really be nicer for internal/cpu to figure out this
	// flag by itself. Then we wouldn't need to depend on quirks of

			// Policy for bindings doesn't exist. This can happen if the policy
			// was deleted before the binding, or the binding was created first.
			//
			// Just skip bindings that refer to non-existent policies
			// If the policy is recreated, the cache will be marked dirty and
			// this function will run again.
			continue
		} else if err != nil {
			// This should never happen since fetching from a cache should never

// returns file mode creation mask.
func getUmask() int {
	mask := syscall.Umask(0)
	syscall.Umask(mask)
	return mask
}

// Tests if the directory and file creations happen with proper umask.
func TestIsValidUmaskVol(t *testing.T) {
	tmpPath := t.TempDir()
	testCases := []struct {
		volName       string
		expectedUmask int
	}{
		{"is-this-valid", getUmask()},
	}

		if err != nil && !errors.IsNotFound(err) {
			klog.ErrorS(err, "Error getting lease")
			continue
		}
		if errors.IsNotFound(err) || lease == nil {
			// In an HA cluster, this can happen if the lease was deleted
			// by the same GC controller in another apiserver, which is legit.
			// We don't expect other components to delete the lease.
			klog.V(4).InfoS("Cannot find apiserver lease", "err", err)

# Regression test for Issue #62663: we would filter out the toolchain and
# main modules from the build list incorrectly, leading to the workspace
# modules being checked for correct sums. Specifically this would happen when
# the module name sorted after the virtual 'go' version module name because
# it could not get chopped off when we removed the MainModules.Len() modules
# at the beginning of the build list and we would remove the go module instead.

go mod verify

    static boolean shouldBePublished(PublishArtifact artifact) {
        if (artifact instanceof PublishArtifactInternal) {
            return ((PublishArtifactInternal) artifact).shouldBePublished();
        }
        // This can happen for custom publish artifacts
        return true;
    }

		if nr > 0 { // before dealing with the read error
			nw, ew := dst.Write(buf[0:nr])
			log.Debugf("write %v/%v", nw, ew)
			if f, ok := dst.(http.Flusher); ok {
				f.Flush()
			}
			if nr != nw { // Should not happen
				ew = io.ErrShortWrite
			}
			if ew != nil {
				return
			}
		}
		if err != nil {
			// read is already closed - we need to close out
			_ = closeWriter(dst)
			return
		}
	}
}

// order. So again, it ends up calling the wrong method.
//
// Also, this function is marked noinline because it's critical to the
// test that the interface method call happen in this compilation
// unit, and the itab construction happens in c.go.
//
//go:noinline
func F2(i interface {
	m()
	a.I // embeds m() from package a
}) {
	i.m()