when:
        run "wrapper", "--no-validate-url"

        then:
        new ZipTestFixture(file("gradle/wrapper/gradle-wrapper.jar"))
            .assertFileContent("META-INF/LICENSE", containsString("Apache License"))
    }

    def "generated wrapper scripts for given version from command-line"() {
        when:
        run "wrapper", "--gradle-version", "2.2.1", "--no-validate-url"

        then:

limitations under the License.
*/

package common

import (
	"reflect"
	"time"
)

// CorrelatedObject represents a node in a tree of objects that are being
// validated. It is used to keep track of the old value of an object during
// traversal of the new value. It is also used to cache the results of
// DeepEqual comparisons between the old and new values of objects.
//

}

// validateMinCandidateNodesAbsolute validates that minCandidateNodesAbsolute
// is within the allowed range.
func validateMinCandidateNodesAbsolute(minCandidateNodesAbsolute int32, p *field.Path) *field.Error {
	if minCandidateNodesAbsolute < 0 {
		return field.Invalid(p, minCandidateNodesAbsolute, "not in valid range [0, inf)")
	}
	return nil
}

// ValidateInterPodAffinityArgs validates that InterPodAffinityArgs are correct.

                    tasks.create("validate") {
                        assert components*.binaries*.values().flatten()*.name == ["jar"]
                    }
                }
            }
            apply plugin: ValidateTaskRules
        """

        expect:
        succeeds "validate"

        where:

  protected Set<E> delegate() {
    validate();
    return delegate;
  }

  private InvalidatableSet(
      Set<E> delegate, Supplier<Boolean> validator, Supplier<String> errorMessage) {
    this.delegate = delegate;
    this.validator = validator;
    this.errorMessage = errorMessage;
  }

  // Override hashCode() to access delegate directly (so that it doesn't trigger the validate() call

			ssParity, minParityDrives)
	}

	if ssParity > setDriveCount/2 {
		return fmt.Errorf("parity %d should be less than or equal to %d", ssParity, setDriveCount/2)
	}

	return nil
}

// Validates the parity drives.
func validateParity(ssParity, rrsParity, setDriveCount int) (err error) {
	// SS parity drives should be greater than or equal to minParityDrives.
	// Parity below minParityDrives is not supported.

            @MapKey("name") String name,
            @MapKey("version") String version) {

            return DefaultModuleComponentIdentifier.newId(
                DefaultModuleIdentifier.newId(validate(group.trim()), validate(name.trim())),
                validate(version.trim())
            );
        }
    }

    static class StringNotationConverter extends TypedNotationConverter<String, ModuleComponentIdentifier> {

		return nil
	}
	return fmt.Errorf("Don't validate")
}

func makeHandler(name string, accept bool, ops ...Operation) *FakeHandler {
	return &FakeHandler{
		name:     name,
		admit:    accept,
		validate: accept,
		Handler:  NewHandler(ops...),
	}
}

func TestAdmitAndValidate(t *testing.T) {
	sysns := metav1.NamespaceSystem
	otherns := "default"
	tests := []struct {
		name      string

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/validation/field"
	authorizationapi "k8s.io/kubernetes/pkg/apis/authorization"
)

// ValidateSubjectAccessReviewSpec validates a SubjectAccessReviewSpec and returns an
// ErrorList with any errors.
func ValidateSubjectAccessReviewSpec(spec authorizationapi.SubjectAccessReviewSpec, fldPath *field.Path) field.ErrorList {
	allErrs := field.ErrorList{}

		entityKeysInStorage.Add(k)
		return true
	})

	return entityKeysInStorage
}

// NormalizeLDAPMappingImport - validates the LDAP policy mappings. Keys in the
// given map may not correspond to LDAP DNs - these keys are ignored.
//
// For validated mappings, it updates the key in the given map to be in
// normalized form.
func (sys *IAMSys) NormalizeLDAPMappingImport(ctx context.Context, isGroup bool,