'org.test:projectA:1.0' {
                withModule {
                    withExtraInfo((IvySpecificComponentMetadataRulesIntegrationTest.ns('foo')): "fooValue", (IvySpecificComponentMetadataRulesIntegrationTest.ns('bar')): "barValue")
                    withBranch('someBranch')
                    withStatus('release')
                }
            }
        }

        buildFile <<
            """

        then:
        ivyXml.info."foo".size() == 1
        ivyXml.info."foo"[0].namespaceURI() == "http://namespace/foo"
        ivyXml.info."foo"[0].text() == 'fooValue'
        ivyXml.info."bar".size() == 1
        ivyXml.info."bar"[0].namespaceURI() == "http://namespace/bar"
        ivyXml.info."bar"[0].text() == 'barValue'
    }

                foo:
                - bar: fizz
                  val: fizzValue
                - bar: baz
                  val: barValue
            `),
			Schema: mustSchema(`
                properties:
                  foo:
                    type: array
                    items:
                      type: object
                      properties:
                        bar:

				&field.Error{
					Type:     field.ErrorTypeInvalid,
					Field:    "values",
					BadValue: []string{},
				},
			},
		},
		{
			Key:  "x2",
			Op:   selection.NotIn,
			Vals: sets.NewString(),
			WantErr: field.ErrorList{
				&field.Error{
					Type:     field.ErrorTypeInvalid,
					Field:    "values",
					BadValue: []string{},
				},
			},
		},
		{
			Key:  "x3",

	}
}

func TestValidatePodSchedulingContexts(t *testing.T) {
	goodName := "foo"
	goodNS := "ns"
	goodPodSchedulingSpec := resource.PodSchedulingContextSpec{}
	now := metav1.Now()
	badName := "!@#$%^"
	badValue := "spaces not allowed"

	scenarios := map[string]struct {
		schedulingCtx *resource.PodSchedulingContext
		wantFailures  field.ErrorList
	}{
		"good-schedulingCtx": {

	goodName := "foo"
	badName := "!@#$%^"
	goodNS := "ns"
	goodClaimSpec := resource.ResourceClaimSpec{
		ResourceClassName: goodName,
		AllocationMode:    validMode,
	}
	now := metav1.Now()
	badValue := "spaces not allowed"
	badAPIGroup := "example.com/v1"
	goodAPIGroup := "example.com"

	scenarios := map[string]struct {
		template     *resource.ResourceClaimTemplate
		wantFailures field.ErrorList
	}{

		},
		DriverRequests: requests,
	}
}

var goodRequests []resource.DriverRequests

func TestValidateResourceClaimParameters(t *testing.T) {
	goodName := "foo"
	badName := "!@#$%^"
	badValue := "spaces not allowed"
	now := metav1.Now()

	scenarios := map[string]struct {
		parameters   *resource.ResourceClaimParameters
		wantFailures field.ErrorList
	}{
		"good": {

			Namespace: namespace,
		},
		Filters: filters,
	}
}

var goodFilters []resource.ResourceFilter

func TestValidateResourceClassParameters(t *testing.T) {
	goodName := "foo"
	badName := "!@#$%^"
	badValue := "spaces not allowed"
	now := metav1.Now()

	scenarios := map[string]struct {
		parameters   *resource.ResourceClassParameters
		wantFailures field.ErrorList
	}{
		"good": {

	goodName := "foo"
	now := metav1.Now()
	goodParameters := resource.ResourceClassParametersReference{
		Name:      "valid",
		Namespace: "valid",
		Kind:      "foo",
	}
	badName := "!@#$%^"
	badValue := "spaces not allowed"
	badAPIGroup := "example.com/v1"
	goodAPIGroup := "example.com"

	scenarios := map[string]struct {
		class        *resource.ResourceClass
		wantFailures field.ErrorList
	}{

	case v.Type == ErrorTypeForbidden:
		s = v.Type.String()
	case v.Type == ErrorTypeTooLong:
		s = v.Type.String()
	case v.Type == ErrorTypeInternal:
		s = v.Type.String()
	case v.BadValue == omitValue:
		s = v.Type.String()
	default:
		value := v.BadValue
		valueType := reflect.TypeOf(value)
		if value == nil || valueType == nil {
			value = "null"
		} else if valueType.Kind() == reflect.Pointer {