*/
    <T> T newInstance(Object... args);

    /**
     * 引数の型に応じた{@link ConstructorDesc}を返します。
     *
     * @param paramTypes
     *            コンストラクタに渡す引数型の並び
     * @return 引数の型に応じた{@link ConstructorDesc}
     */
    ConstructorDesc getConstructorDesc(Class<?>... paramTypes);

    /**
     * 引数に適合する{@link ConstructorDesc}を返します。
     *
     * @param args
     *            コンストラクタに渡す引数の並び

    def method(Map<String, ?> args, String name, ClassMetaData classMetaData) {
        MethodMetaData method = Mock()
        List<String> paramTypes = args.paramTypes ?: []
        _ * method.name >> name
        _ * method.overrideSignature >> "$name(${paramTypes.join(', ')})"
        _ * method.parameters >> paramTypes.collect {
            def param = new ParameterMetaData("p");
            param.type = new TypeMetaData(it)
            return param

     * @param paramTypes the classes of method parameters
     */
    private static Method getPublicMethod(Class<?> clazz, String name, Class<?>... paramTypes) {
        // if this class is public, then try to get it
        if ((clazz.getModifiers() & Modifier.PUBLIC) != 0) {
            try {
                return clazz.getMethod(name, paramTypes);
            } catch (NoSuchMethodException e) {

from ._compat import PYDANTIC_V2, PYDANTIC_VERSION, Undefined

_Unset: Any = Undefined


class ParamTypes(Enum):
    query = "query"
    header = "header"
    path = "path"
    cookie = "cookie"


class Param(FieldInfo):
    in_: ParamTypes

    def __init__(
        self,
        default: Any = Undefined,
        *,

    }

    def "the @since annotation on implicit enum method '#implicitMethod#paramTypes' is not required"() {
        given:
        def rule = withContext(new SinceAnnotationMissingRule([:]))
        def jApiMethod = Stub(JApiMethod)
        jApiMethod.name >> implicitMethod
        jApiMethod.jApiClass >> jApiClassifier
        jApiMethod.parameters >> paramTypes.collect { paramStub(it) }

        when:
        sourceFile.text = """

    if field_info_in == params.ParamTypes.path:
        dependant.path_params.append(field)
    elif field_info_in == params.ParamTypes.query:
        dependant.query_params.append(field)
    elif field_info_in == params.ParamTypes.header:
        dependant.header_params.append(field)
    else:
        assert (
            field_info_in == params.ParamTypes.cookie

		{"Field.Class", Field, 5},
		{"Field.Val", Field, 0},
		{"FloatType", Type, 0},
		{"FloatType.BasicType", Field, 0},
		{"FuncType", Type, 0},
		{"FuncType.CommonType", Field, 0},
		{"FuncType.ParamType", Field, 0},
		{"FuncType.ReturnType", Field, 0},
		{"IntType", Type, 0},
		{"IntType.BasicType", Field, 0},
		{"LineEntry", Type, 5},
		{"LineEntry.Address", Field, 5},
		{"LineEntry.BasicBlock", Field, 5},

pkg debug/dwarf, type FloatType struct
pkg debug/dwarf, type FloatType struct, embedded BasicType
pkg debug/dwarf, type FuncType struct
pkg debug/dwarf, type FuncType struct, ParamType []Type
pkg debug/dwarf, type FuncType struct, ReturnType Type
pkg debug/dwarf, type FuncType struct, embedded CommonType
pkg debug/dwarf, type IntType struct
pkg debug/dwarf, type IntType struct, embedded BasicType