def executable = Mock(File)
        def commandLineTool = new DefaultCommandLineToolInvocationWorker("Tool", executable, execActionFactory)
        def invocation = new DefaultCommandLineToolInvocation("doing something", null, [], context, Mock(BuildOperationLogger))

        when:
        commandLineTool.execute(invocation, null)

        then:
        1 * execAction.executable(executable)

something to copy...

Something to copy...

//go:build !(x || y) && z
// +build something else

     */
    ImmutableSet<Class<? extends Annotation>> getAllowedModifiers();

    /**
     * Does this handler do something useful with the properties that match it? Or can these properties be ignored?
     *
     * Should consider splitting up this type, perhaps into something that inspects the properties and produces the actual handlers and validation problems.
     */
    boolean isPropertyRelevant();

    /**

        assertThat(
            lex("\n" +
                "/* ... */\n" +
                "// she-bangs! ///////_*&@ because why not! _-|\n" +
                "\n" +
                "#!/something/something\n" +
                "\n" +
                "\n" +
                "/* first file annotation */\n" +
                "@file:Suppress(\"UnstableApiUsage\")\n" +
                "\n" +

Something to copy...

# JSON Compatible Encoder

There are some cases where you might need to convert a data type (like a Pydantic model) to something compatible with JSON (like a `dict`, `list`, etc).

For example, if you need to store it in a database.

For that, **FastAPI** provides a `jsonable_encoder()` function.

## Using the `jsonable_encoder`

Let's imagine that you have a database `fake_db` that only receives JSON compatible data.

			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{apps.DefaultDeploymentUniqueLabelKey: "value-2", "something": "else"}),
			true,
		},
		{
			"Same spec, the former doesn't have pod-template-hash label",
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{"something": "else"}),

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package a

type A[T any] struct{}

func (_ A[T]) Method() {}

func DoSomething[P any]() {
	a := A[*byte]{}
	a.Method()