// Check if range string contains delimiter '-', else return error. eg. "bytes=8"
	sepIndex := strings.Index(byteRangeString, "-")
	if sepIndex == -1 {
		return nil, fmt.Errorf("'%s' does not have a valid range value", rangeString)
	}

	offsetBeginString := byteRangeString[:sepIndex]
	offsetBegin := int64(-1)
	// Convert offsetBeginString only if its not empty.
	if len(offsetBeginString) > 0 {

// contain release numbers ("go1.20.1" is not a valid goVersion).
type goVersion string

// asGoVersion returns v as a goVersion (e.g., "go1.20.1" becomes "go1.20").
// If v is not a valid Go version, the result is the empty string.
func asGoVersion(v string) goVersion {
	return goVersion(version.Lang(v))
}

// isValid reports whether v is a valid Go version.
func (v goVersion) isValid() bool {
	return v != ""
}

)

type ErrNotInRange struct {
	IP         net.IP
	ValidRange string
}

func (e *ErrNotInRange) Error() string {
	return fmt.Sprintf("the provided IP (%v) is not in the valid range. The range of valid IPs is %s", e.IP, e.ValidRange)

        and:
        failure.assertHasDescription("Invalid version specified for argument '--gradle-version'")
        failure.assertHasCause("'$badVersion' is not a valid Gradle version string (examples: '1.0', '1.0-rc-1')")
        failure.assertHasResolution("Specify a valid Gradle release listed on https://gradle.org/releases/.")

		expectError:       false,
	}, {
		description:       "valid hostDomain, setHostnameAsFQDN false",
		hostname:          "test.pod.hostname",
		hostDomain:        "svc.subdomain.local",
		setHostnameAsFQDN: false,
		expectedHostname:  "test.pod.hostname",
		expectError:       false,
	}, {
		description:       "valid hostDomain, setHostnameAsFQDN true",
		hostname:          "test.pod.hostname",

	}
	if Strategy.AllowCreateOnUpdate() {
		t.Errorf("VolumeAttributesClassStrategy should not allow create on update")
	}

	class := &storage.VolumeAttributesClass{
		ObjectMeta: metav1.ObjectMeta{
			Name: "valid-class",
		},
		DriverName: "fake",
		Parameters: map[string]string{
			"foo": "bar",
		},
	}

	Strategy.PrepareForCreate(ctx, class)

	errs := Strategy.Validate(ctx, class)
	if len(errs) != 0 {

        when:
        ruleActionAdapter.createFromClosure(String, {List subject -> })

        then:
        def failure = thrown(InvalidUserCodeException)
        failure.message == "The closure provided is not valid as a rule for 'context'."
        failure.cause instanceof RuleActionValidationException
        failure.cause.message == "First parameter of rule action closure must be of type 'String'."
    }

        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["body", "size"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "XL",
                }
            ],
            "body": {"title": "towel", "size": "XL"},
        }
    ) | IsDict(

                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "foo",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",

func TestCreateCredentials(t *testing.T) {
	testCases := []struct {
		accessKey   string
		secretKey   string
		valid       bool
		expectedErr error
	}{
		// Valid access and secret keys with minimum length.
		{alphaNumericTable[:accessKeyMinLen], alphaNumericTable[:secretKeyMinLen], true, nil},
		// Valid access and/or secret keys are longer than minimum length.