func IsHTTPURL(path string) (bool, error) {
	u, err := url.Parse(path)
	valid := err == nil && u.Host != "" && (u.Scheme == "http" || u.Scheme == "https")
	if strings.HasPrefix(path, "http") && !valid {
		return false, fmt.Errorf("%s starts with http but is not a valid URL: %s", path, err)
	}
	return valid, nil

			enableRatcheting: false,
			crd: &apiextensions.CustomResourceDefinition{
				ObjectMeta: metav1.ObjectMeta{Name: "foos.sigs.k8s.io", Annotations: map[string]string{v1beta1.KubeAPIApprovedAnnotation: "valid"}, ResourceVersion: "1"},
				Spec: apiextensions.CustomResourceDefinitionSpec{
					Validation: &apiextensions.CustomResourceValidation{
						OpenAPIV3Schema: &apiextensions.JSONSchemaProps{
							Type: "object",

		name  string
		tags  labels.Instance
		valid bool
	}{
		{
			name:  "empty tags",
			valid: true,
		},
		{
			name: "bad tag",
			tags: labels.Instance{"^": "^"},
		},
		{
			name:  "good tag",
			tags:  labels.Instance{"key": "value"},
			valid: true,
		},
		{
			name:  "good tag - empty value",
			tags:  labels.Instance{"key": ""},
			valid: true,
		},
		{

    /**
     * The configuration of the linker used when linking this binary.
     *
     * Valid for {@link SharedLibraryBinarySpec} and {@link NativeExecutableBinarySpec}.
     */
    Tool getLinker();

    /**
     * The configuration of the static library archiver used when creating this binary.
     *
     * Valid for {@link StaticLibraryBinarySpec}.
     */
    Tool getStaticLibArchiver();

    /**

                    # but since the key is not valid, openapi.utils.get_openapi will raise ValueError
                    "hello": {"description": "Not a valid additional response"},
                    "200": {
                        "description": "Successful Response",
                        "content": {"application/json": {"schema": {}}},
                    },
                },

[!short] go build ./importjson  # Prove that it works when GOROOT is valid.

env GOROOT=$WORK/not-a-valid-goroot
! go build ./importjson
! stderr 'import lookup disabled'
! stderr 'missing dot'
stderr 'importjson[/\\]x.go:2:8: package encoding/json is not in std \('$WORK'[/\\]not-a-valid-goroot[/\\]src[/\\]encoding[/\\]json\)$'

-- go.mod --
module example.com
go 1.14
-- importnonexist/x.go --

	check.nonGeneric(nil, x)
	if x.mode == invalid {
		return false
	}

	// ordinary index expression
	valid := false
	length := int64(-1) // valid if >= 0
	switch typ := under(x.typ).(type) {
	case *Basic:
		if isString(typ) {
			valid = true
			if x.mode == constant_ {
				length = int64(len(constant.StringVal(x.val)))
			}
			// an indexed string always yields a byte value

		name           string
		config         eventratelimitapi.Configuration
		expectedResult bool
	}{{
		name: "valid server",
		config: eventratelimitapi.Configuration{
			Limits: []eventratelimitapi.Limit{{
				Type:  "Server",
				Burst: 5,
				QPS:   1,
			}},
		},
		expectedResult: true,
	}, {
		name: "valid namespace",
		config: eventratelimitapi.Configuration{
			Limits: []eventratelimitapi.Limit{{

        if (field.getDeclaringClass().equals(source.getConcreteClass())) {
            problems.add("Field " + field.getName() + " is not valid: " + problem);
        } else {
            problems.add("Field " + ModelType.of(field.getDeclaringClass()).getDisplayName() + '.' + field.getName() + " is not valid: " + problem);
        }
    }

    @Override
    public void add(Method method, String role, String problem) {

		parsingError bool
	}
	cases := []T{
		{
			name:   "valid version with label and metadata",
			input:  "v1.8.0-alpha.2.1231+afabd012389d53a",
			output: "v1.8.0-alpha.2",
		},
		{
			name:   "valid version with label and extra metadata",
			input:  "v1.8.0-alpha.2.1231+afabd012389d53a.extra",
			output: "v1.8.0-alpha.2",
		},
		{
			name:   "valid patch version with label and extra metadata",