given:
        manager.addListener(Stub(StatefulTestListener))
        def broadcaster = manager.getBroadcaster(StatefulTestListener)
        manager.addListener(Stub(StatefulTestListener))
        broadcaster.something("12")

        when:
        manager.addListener(Stub(StatefulTestListener))

        then:
        def e = thrown(IllegalStateException)

	if e.Kind() != reflect.Struct {
		return validationErrors
	}
	for i := 0; i < e.NumField(); i++ {
		// Corner case of a slice of something, if something is defined type, then process it recursively.
		if e.Field(i).Kind() == reflect.Slice {
			validationErrors = append(validationErrors, processSlice(e.Field(i), failOnMissingValidation, values, iopls)...)
			continue

            return Value.of(emptyCollection());
        }

        @Override
        public CollectionSupplier<T, C> plus(Collector<T> collector) {
            // empty + something = something
            return new CollectingSupplier(collector);
        }

        @Override
        public CollectionSupplier<T, C> absentIgnoring() {
            return this;
        }

// Dead stores are those which are unconditionally followed by
// another store to the same location, with no intervening load.
// This implementation only works within a basic block. TODO: use something more global.
func dse(f *Func) {
	var stores []*Value
	loadUse := f.newSparseSet(f.NumValues())
	defer f.retSparseSet(loadUse)
	storeUse := f.newSparseSet(f.NumValues())
	defer f.retSparseSet(storeUse)

The `response_class` will then be used only to document the OpenAPI *path operation*, but your `Response` will be used as is.

#### Return an `HTMLResponse` directly

For example, it could be something like:

```Python hl_lines="7  21  23"
{!../../../docs_src/custom_response/tutorial004.py!}
```

Although you use `Depends` in the parameters of your function the same way you use `Body`, `Query`, etc, `Depends` works a bit differently.

You only give `Depends` a single parameter.

This parameter must be something like a function.

You **don't call it** directly (don't add the parenthesis at the end), you just pass it as a parameter to `Depends()`.

And that function takes parameters in the same way that *path operation functions* do.

	copy(finalHash[:], fh)
	finalHashComputed = true
	finalMetaLen = tlen

	return ml, nil
}

// emitMetaDataToDirectory emits the meta-data output file to the specified
// directory, returning an error if something went wrong.
func emitMetaDataToDirectory(outdir string, ml []rtcov.CovMetaBlob) error {
	ml, err := prepareForMetaEmit()
	if err != nil {
		return err
	}
	if len(ml) == 0 {
		return nil
	}

                String toString() { null }
            }
            model {
                something(SomeType)
            }
        """.stripIndent()

        when:
        succeeds 'model'

        then:
        def modelNode = ModelReportOutput.from(output).modelNode
        modelNode.something[0].nodeValue == 'SomeType#toString() returned null'
    }

    private String managedNumbers() {

        def someTask = ":someTask"
        def someTaskOutput = file("build/overlap/someTask.txt")
        someTaskOutput.text = "Created by something else"

        when:
        withBuildCache().run(someTask)
        then:
        // someTask cannot be cached because its outputs were created by something else
        assertTaskOutputNotCached(someTask)
        someTaskOutput.text == "Generated by ${someTask}"
    }

	// Rewrite mentions of dir with a relative path to dir
	// when the relative path is shorter.
	for {
		// Note that dir starts out long, something like
		// /foo/bar/baz/root/a
		// The target string to be reduced is something like
		// (blah-blah-blah) /foo/bar/baz/root/sibling/whatever.go:blah:blah
		// /foo/bar/baz/root/a doesn't match /foo/bar/baz/root/sibling, but the prefix