}

    def "can add a converter"() {
        def converter = Mock(NotationConverter)

        given:
        converter.convert(_, _) >> { Object n, NotationConvertResult result -> result.converted("[${n}]") }

        and:
        def parser = NotationParserBuilder.toType(String.class).converter(converter).toComposite()

        expect:
        parser.parseNotation(12) == "[12]"

    def converter = Mock(NotationConverter)
    def parser = new NotationConverterToNotationParserAdapter(converter)

    def "converts notation"() {
        given:
        converter.convert(12, _) >> { Object notation, NotationConvertResult result -> result.converted("12") }

        expect:
        parser.parseNotation(12) == "12"
    }

    def "can convert to null value"() {
        given:

    }

    def "can convert stop option - #options"() {
        when:
        def converted = convert(options)

        then:
        converted.stop == stop

        where:
        options    | stop
        []         | false
        ['--stop'] | true
    }

    def "can convert status option - #options"() {
        when:
        def converted = convert(options)

        then:

// This helper function makes legality check easier. Both convert ops in the
// patterns below are considered legal:
//  - `BitcastConvertOp` (i32 -> f32) + `ConvertOp` (f32 -> bf16)
//  - `ConvertOp` (bf16 -> f32) -> `BitcastConvertOp` (f32 -> i32)
template <typename ConvertOp, typename OtherConvertOp>
bool IsConvertOpLegal(ConvertOp convert_op, BFloat16TypeConverter& converter) {
  if (!converter.isLegal(convert_op.getOperand().getType())) {

Rob Pike <******@****.***> 1329617983 +1100

        return NotationParserBuilder
            .toType(type)
            .noImplicitConverters()
            .converter(converter)
            .toComposite();
    }

    private <T> void registerConverter(NotationConverter<Object, T> converter, Class<T> type) {
        parsers.put(type, build(converter, type));
    }

	s = (*S)(t)
	s = (*S)(u) // ERROR "cannot convert"
	t = u       // ERROR "cannot use .* in assignment|incompatible type"
	t = (*T)(u) // ERROR "cannot convert"
}

func _() {
	var s []byte
	_ = ([4]byte)(s)
	_ = (*[4]byte)(s)

	type A [4]byte
	_ = (A)(s)
	_ = (*A)(s)

	type P *[4]byte
	_ = (P)(s)
	_ = (*P)(s) // ERROR "cannot convert"

Rob Pike <******@****.***> 1329633221 +1100

*/

package schema

import (
	"fmt"

	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions"
	apiextensionsv1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
)

// NewStructural converts an OpenAPI v3 schema into a structural schema. A pre-validated JSONSchemaProps will
// not fail on NewStructural. This means that we require that:
//
// - items is not an array of schemas
// - the following fields are not set:

	_ = string(si) // ERROR "cannot convert.* string|invalid type conversion"
	_ = []byte(si) // ERROR "cannot convert.*\[\]byte|invalid type conversion"
	_ = []rune(si) // ERROR "cannot convert.*\[\]rune|invalid type conversion"
	_ = []int64(si)
	_ = Tstring(si) // ERROR "cannot convert.*Tstring|invalid type conversion"
	_ = Tbyte(si)   // ERROR "cannot convert.*Tbyte|invalid type conversion"