},
			Items: &schema.Structural{
				Generic: schema.Generic{
					Type: passedType,
				},
				ValueValidation: &schema.ValueValidation{
					Format: passedFormat,
				},
				Extensions: schema.Extensions{
					XIntOrString: xIntString,
				},
			},
			ValueValidation: &schema.ValueValidation{
				MaxItems: maxItems,
			},
			ValidationExtensions: schema.ValidationExtensions{

	if s == nil || s.ValueValidation == nil {
		return false
	}
	return len(s.ValueValidation.AnyOf) == 2 && reflect.DeepEqual(s.ValueValidation.AnyOf, intOrStringAnyOf)
}

func isIntOrStringAllOfPattern(s *Structural) bool {
	if s == nil || s.ValueValidation == nil {
		return false
	}

type Structural struct {
	Items                *Structural
	Properties           map[string]Structural
	AdditionalProperties *StructuralOrBool

	Generic
	Extensions
	ValidationExtensions

	ValueValidation *ValueValidation
}

// +k8s:deepcopy-gen=true

// StructuralOrBool is either a structural schema or a boolean.
type StructuralOrBool struct {
	Structural *Structural
	Bool       bool
}

func (s *Structural) StripValueValidations() *Structural {
	s = s.DeepCopy()
	v := Visitor{
		Structural: func(s *Structural) bool {
			changed := false
			if s.ValueValidation != nil {
				s.ValueValidation = nil
				changed = true
			}
			return changed
		},
	}
	v.Visit(s)
	return s
}

// StripNullable returns a copy without nullable.

	if s == nil {
		return nil
	}

	return validateValueValidationCompleteness(s.ValueValidation, s, fldPath, fldPath, opts)
}

func validateValueValidationCompleteness(v *ValueValidation, s *Structural, sPath, vPath *field.Path, opts ValidationOptions) field.ErrorList {
	if v == nil {
		return nil
	}
	if s == nil {

			Allows: s.AdditionalProperties.Bool,
			Schema: s.AdditionalProperties.Structural.ToKubeOpenAPI(),
		}
	}
	s.Generic.toKubeOpenAPI(ret)
	s.Extensions.toKubeOpenAPI(ret)
	s.ValueValidation.toKubeOpenAPI(ret)
	s.ValidationExtensions.toKubeOpenAPI(ret)
	return ret
}

func (g *Generic) toKubeOpenAPI(ret *spec.Schema) {
	if g == nil {
		return
	}

	if len(g.Type) != 0 {

limitations under the License.
*/

package schema

import (
	"testing"
)

// TestStructuralUnfoldNilValueValidation tests that Unfold() does not crash
// on a IntOrString pattern with nil ValueValidation.
func TestStructuralUnfoldIntOrString(t *testing.T) {
	schema := Structural{
		Extensions: Extensions{
			XIntOrString: true,
		},
	}
	schema.Unfold()

	}

	return g, nil
}

func newValueValidation(s *apiextensions.JSONSchemaProps) (*ValueValidation, error) {
	if s == nil {
		return nil, nil
	}
	not, err := newNestedValueValidation(s.Not)
	if err != nil {
		return nil, err
	}
	v := &ValueValidation{
		Format:           s.Format,
		Maximum:          s.Maximum,
		ExclusiveMaximum: s.ExclusiveMaximum,

		return s
	}
	result := &schema.Structural{
		AdditionalProperties: s.AdditionalProperties,
		Generic:              s.Generic,
		Extensions:           s.Extensions,
		ValueValidation:      s.ValueValidation,
		ValidationExtensions: s.ValidationExtensions,
	}
	props := make(map[string]schema.Structural, len(s.Properties))
	for k, prop := range s.Properties {
		props[k] = prop
	}

	if s.ValueValidation == nil {
		s.ValueValidation = &schema.ValueValidation{}
	}
	s.ValueValidation.MaxLength = maxLength
	return s
}

func withMaxItems(s schema.Structural, maxItems *int64) schema.Structural {
	if s.ValueValidation == nil {
		s.ValueValidation = &schema.ValueValidation{}
	}
	s.ValueValidation.MaxItems = maxItems
	return s
}