"float"      | "0.1f"        | "+ 0.2f"
        "double"     | "0.1"         | "+ 0.2"
        "short"      | "1"           | "+ 1"
        "byte"       | "1"           | "+ 1"
        "String"     | "\"hello\""   | "+ \"world\""
        "int"        | "1"           | "+ 2"
        "boolean"    | "true"        | "& false"
    }

    def "collect all constants from class fields"() {
        given:

 */
class ExternalProcessFixture {
    private final TestFile testDirectory
    private final ShellScript testExecutable = ShellScript.builder()
        .printText("Hello from script")
        .writeTo(testDirectory, "test")

    ExternalProcessFixture(TestFile testDirectory) {
        this.testDirectory = testDirectory
    }

    private String getCommandLineAsVarargLiterals() {

		{
			objectName:         "test",
			data:               []byte("Hello, World"),
			expectedRespStatus: http.StatusForbidden,
			accessKey:          "",
			secretKey:          "",
			malformedBody:      false,
		},
		// Bad case malformed input.
		{
			objectName:         "test",
			data:               []byte("Hello, World"),
			expectedRespStatus: http.StatusBadRequest,

        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("Hello, WebSockets!")
    serverListener.assertTextMessage("Hello, WebSockets!")
    closeWebSockets(webSocket, server)
  }

  @Test
  fun binaryMessage() {
    webServer.enqueue(
      MockResponse.Builder()

		if string(data) != "hello" {
			t.Errorf(`bytes a = %q not "hello"`, string(data))
		}
	}

	// string
	{
		var data string
		instr := &decInstr{decString, 6, nil, ovfl}
		state := newDecodeStateFromData(bytesResult)
		execDec(instr, state, t, reflect.ValueOf(&data))
		if data != "hello" {
			t.Errorf(`bytes a = %q not "hello"`, data)
		}
	}
}

            dependencies {
                runtime "org.test:first:latest.integration"
            }

            task resolve {
                dependsOn configurations.runtime
                ext.message = "hello world"
                ext.dependencies = []
                ext.assertions = []
                doLast {
                    def resolved = configurations.runtime.files
                    println "Looking for " + message

### Crea un file

* Crea un file `main.py` con:

```Python
from fastapi import FastAPI
from typing import Optional

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = Optional[None]):
    return {"item_id": item_id, "q": q}
```

<details markdown="1">

			ownerUID:     []types.UID{`ss1"hello`},
			dependentUID: "ss2",
			finalizers:   []string{},
			want:         []byte(`{"metadata":{"uid":"ss2","ownerReferences":[{"$patch":"delete","uid":"ss1\"hello"}]}}`),
		},
		{
			name:         "check if revision uid uid is escaped",
			ownerUID:     []types.UID{`ss1`},
			dependentUID: `ss2"hello`,
			finalizers:   []string{},

		t.Fatalf("1st Sum after hello world = %x, want %x", sum, sumHelloWorld)
	}
	if sum := h.Sum(nil); !bytes.Equal(sum, sumHelloWorld) {
		t.Fatalf("2nd Sum after hello world = %x, want %x", sum, sumHelloWorld)
	}

	h.Reset()
	h.Write([]byte("hello"))
	if sum := h.Sum(nil); !bytes.Equal(sum, sumHello) {
		t.Fatalf("Sum after Reset + hello = %x, want %x", sum, sumHello)
	}
}

func BenchmarkHMACSHA256_1K(b *testing.B) {

//	s = s.WithLabels("foo", "bar", "baz", 123, "qux", 0.123)
//	s.Info("Hello")                      // <time>   info   MyScope   Hello  foo=bar baz=123 qux=0.123
//
// The output format can be globally configured to be JSON instead, using Options in this package.
//
//	e.g. <time>   info   MyScope   { "message":"Hello","foo":"bar","baz":123 }
//