for _, x := range xl {
		if x != nil && x.typ == nil {
			return true
		}
	}
	return false
}

// norm returns the normal form of xl.
func (xl termlist) norm() termlist {
	// Quadratic algorithm, but good enough for now.
	// TODO(gri) fix asymptotic performance
	used := make([]bool, len(xl))
	var rl termlist
	for i, xi := range xl {
		if xi == nil || used[i] {
			continue
		}
		for j := i + 1; j < len(xl); j++ {

	// Final argument is (basep *uintptr) and the syscall doesn't take nil.
	// 64 bits should be enough. (32 bits isn't even on 386). Since the
	// actual system call is getdirentries64, 64 is a good guess.
	// TODO(rsc): Can we use a single global basep for all calls?
	var base = (*uintptr)(unsafe.Pointer(new(uint64)))
	return Getdirentries(fd, buf, base)

	var out []int64
	for i := 0; i < 10; i++ {
		out = append(out, Int64())
	}

	// Look for out in seeded output.
	// Strictly speaking, we should look for them in order,
	// but this is good enough and not significantly more
	// likely to have a false positive.
	r := New(NewPCG(1, 0))
	found := 0
	for i := 0; i < 1000; i++ {
		x := r.Int64()
		if x == out[found] {
			found++
			if found == len(out) {

    private manager = new ExclusiveFileAccessManager(1000, 10)

    def 'If the directory for the lock file cannot be created then we get a good error message'() {
        given:
        def fileWithSameNameAsDirectory = temporaryDirectory.createFile('someDir')
        when:
        manager.access(fileWithSameNameAsDirectory.file('someFile.zip')) {
        }

            }
        """
        def module = mavenHttpRepo.module('org.foo', 'good').publish()
        server.authenticationScheme = AuthScheme.BASIC
        server.allowGetOrHead('/repo/org/foo/good/1.0/good-1.0.pom', 'foo', 'bar', module.pomFile)
        server.allowGetOrHead('/repo/org/foo/good/1.0/good-1.0.jar', 'foo', 'bar', module.artifactFile)

        when:
        succeeds 'resolve'

        then:

	badName := "!@#$%^"
	badValue := "spaces not allowed"
	now := metav1.Now()

	scenarios := map[string]struct {
		parameters   *resource.ResourceClassParameters
		wantFailures field.ErrorList
	}{
		"good": {
			parameters: testResourceClassParameters(goodName, goodName, goodFilters),
		},
		"missing-name": {
			wantFailures: field.ErrorList{field.Required(field.NewPath("metadata", "name"), "name or generateName is required")},

To **deploy** an application means to perform the necessary steps to make it **available to the users**.

For a **web API**, it normally involves putting it in a **remote machine**, with a **server program** that provides good performance, stability, etc, so that your **users** can **access** the application efficiently and without interruptions or problems.

	badName := "!@#$%^"
	badValue := "spaces not allowed"
	now := metav1.Now()

	scenarios := map[string]struct {
		parameters   *resource.ResourceClaimParameters
		wantFailures field.ErrorList
	}{
		"good": {
			parameters: testResourceClaimParameters(goodName, goodName, goodRequests),
		},
		"missing-name": {
			wantFailures: field.ErrorList{field.Required(field.NewPath("metadata", "name"), "name or generateName is required")},

    id("gradlebuild.distribution.api-java")
}

description = """A problems description API
    |
    |This project provides base classes to describe problems and their
    |solutions, in a way that enforces the creation of good error messages.
    |
    |It's a stripped down version of the original code available
    |at https://github.com/melix/jdoctor/
""".trimMargin()

gradlebuildJava.usedInWorkers()

dependencies {

			// disappeared entirely
			log.Printf("Good news! Unwanted dependency %q is no longer referenced. Remove status.unwantedReferences[%q] in %s to ensure it doesn't get reintroduced.", expectedRef, expectedRef, dependenciesJSONPath)
			needUpdate = true
			continue
		}
		removedReferences, unwantedReferences := difference(expectedFrom, actualFrom)
		if len(removedReferences) > 0 {