<params>
                <param>forcedIOModelVersion=1.2.0</param>
                <param>packageModelV3=org.apache.maven.settings</param>
                <param>packageModelV4=org.apache.maven.api.settings</param>
                <param>packageToolV4=org.apache.maven.settings.v4</param>
                <param>locationTracking=true</param>
                <param>generateLocationClasses=true</param>
              </params>

     * Logs the given message at the given log level.
     *
     * @param level the log level.
     * @param message the log message.
     */
    void log(LogLevel level, String message);

    /**
     * Logs the given message at the given log level.
     *
     * @param level the log level.
     * @param message the log message.
     * @param objects the log message parameters.
     */

@app.get("/path/param-min_maxlength/{item_id}")
def get_path_param_min_max_length(item_id: str = Path(max_length=3, min_length=2)):
    return item_id


@app.get("/path/param-gt/{item_id}")
def get_path_param_gt(item_id: float = Path(gt=3)):
    return item_id


@app.get("/path/param-gt0/{item_id}")
def get_path_param_gt0(item_id: float = Path(gt=0)):
    return item_id


@app.get("/path/param-ge/{item_id}")

                    param == kFunction.instanceParameter -> put(param, receiver)
                    param == kFunction.extensionReceiverParameter -> put(param, receiver)

                    (hasLambda || param.isOptional) && configureLambdaHandler.getTypeConfiguredByLambda(param.type) != null -> {
                        val newCaptor = configureLambdaHandler.produceValueCaptor(param.type)

     *
     * @param path the file location
     * @param line the one-indexed line number
     * @param column the one-indexed column
     * @param length the length of the text
     * @return this
     * @since 8.6
     */
    ProblemSpec lineInFileLocation(String path, int line, int column, int length);

    /**

@app.get("/int/{param:int}")
def int_convertor(param: int = Path()):
    return {"int": param}


@app.get("/float/{param:float}")
def float_convertor(param: float = Path()):
    return {"float": param}


@app.get("/path/{param:path}")
def path_convertor(param: str = Path()):
    return {"path": param}


@app.get("/query/")
def query_convertor(param: str = Query()):
    return {"query": param}

        }
    }


    /**
     * @param src
     * @param srcIndex
     * @param len
     * @return decoded string
     */
    public static String fromUNIBytes ( byte[] src, int srcIndex, int len ) {
        return new String(src, srcIndex, len, UNI_ENCODING);
    }


    /**
     * @param buffer
     * @param bufferIndex
     * @param maxLen
     * @return position of terminating null bytes

    version: "jdk-11.0.23+9"
    sha256: 23e47ea7a3015be3240f21185fd902adebdcf76530757c9b482c7eb5bd3417c2
  - param: "linux.java17.openjdk.64bit"
    os: linux
    arch: amd64
    vendor: "temurin"
    version: "jdk-17.0.11+9"
    sha256: aa7fb6bb342319d227a838af5c363bfa1b4a670c209372f9e6585bd79da6220c
  - param: "linux.java21.openjdk.64bit"
    os: linux
    arch: amd64
    vendor: "temurin"
    version: "jdk-21.0.3+9"

                def "super unrolled test param=#param"() $unrolledTestBody
            }
        """
        file("src/test/groovy/SubClass.groovy") << """
            class SubClass extends SuperClass {
                def "sub test"() $testBody
                def "sub unrolled test"() $unrolledTestBody
                def "sub unrolled test param=#param"() $unrolledTestBody
            }
        """
    }

        when:
        proxy.doStuff('param')

        then:
        1 * target.doStuff('param') >> {
            assert Thread.currentThread() == testThread
        }
    }

    def blockingActorDispatchesMethodInvocationFromOneThreadAtATime() {
        def target = {param ->
            if (param == 'param') {
                instant.param1Start
                thread.block()