when:
        def result = parser.parse(classMetaData, listener)

        then:
        format(result.docbook) == '''<para>&lt;&gt;&amp; /&gt;</para>'''
    }

    def ignoresHtmlComments() {
        _ * classMetaData.rawCommentText >> '<!-- <p>ignore me</p> --><p>para 1'

        when:
        def result = parser.parse(classMetaData, listener)

        then:

        def annotations = []
        jApiType.annotations >> annotations

        when:
        annotations.clear()

        then:
        rule.maybeViolation(jApiType).humanExplanation =~ 'Is not annotated with @Incubating'

        when:
        annotations.add(incubatingAnnotation)

        then:
        rule.maybeViolation(jApiType) == null

        where:
        apiElement    | jApiTypeName

   * request, and ensure that (1/QPS) seconds have elapsed since then. For example, for a rate of
   * QPS=5 (5 tokens per second), if we ensure that a request isn't granted earlier than 200ms after
   * the last one, then we achieve the intended rate. If a request comes and the last request was
   * granted only 100ms ago, then we wait for another 100ms. At this rate, serving 15 fresh permits

   * <p>If you are escaping input in arbitrary successive chunks, then it is not generally safe to
   * use this method. If an input string ends with an unmatched high surrogate character, then this
   * method will throw {@link IllegalArgumentException}. You should ensure your input is valid <a
   * href="http://en.wikipedia.org/wiki/UTF-16">UTF-16</a> before calling this method.
   *

   * <p>If the dataset contains {@link Double#NaN} then the result is {@link Double#NaN}. If it
   * contains {@link Double#NEGATIVE_INFINITY} and not {@link Double#NaN} then the result is {@link
   * Double#NEGATIVE_INFINITY}. If it contains {@link Double#POSITIVE_INFINITY} and finite values
   * only then the result is the lowest finite value. If it contains {@link
   * Double#POSITIVE_INFINITY} only then the result is {@link Double#POSITIVE_INFINITY}.
   *

   */
  abstract class Listener {
    /**
     * Called when the service transitions from {@linkplain State#NEW NEW} to {@linkplain
     * State#STARTING STARTING}. This occurs when {@link Service#startAsync} is called the first
     * time.
     */
    public void starting() {}

    /**
     * Called when the service transitions from {@linkplain State#STARTING STARTING} to {@linkplain

repository. During development in an IDE we would need layered resolution approach that would allow resolution from the workspace, then the local Maven repository and then from any number of remote Maven repositories. During development from the command line we would need a layered resolution approach that would allow resolution from the local Maven repository and then from any number of remote Maven repositories. In production the resolution for the dependencies could also be layered but would depend...

  Find the control point for m2 using maven-wagon. At this point, inject
  a offline status parameter which is used when retrieving the specific Wagon.

  If <<<offline == true>>>:

  * If the wagon is not bound to "file://", then ignore the request and print
    a debug message.

  * If the wagon is bound to "file://" then:

    Retrieve the file or base-url file to be "downloaded".

name: str
```

Keep these in mind, so you don't get confused when using `=` and `:` with them.

### Create Pydantic *models* / schemas for reading / returning

Now create Pydantic *models* (schemas) that will be used when reading data, when returning it from the API.

For example, before creating an item, we don't know what will be the ID assigned to it, but when reading it (when returning it from the API) we will already know its ID.

        createProject()
    }

    @Test
    fun `should output instrumented-super-types properties with instrumented org-gradle super types with stable order`() {
        // When
        assertSucceeds()

        // Then
        val instrumentedSuperTypes = File(projectRoot, "distribution/build/instrumentation/instrumented-super-types.properties").readLines()
        val expectedSuperTypes = listOf(