system, but will not be uploaded to remote servers.

When telemetry is off, local counter data is neither collected nor uploaded.

When telemetry is on, telemetry data is written to the local file system
and periodically sent to https://telemetry.go.dev/. Uploaded data is used to
help improve the Go toolchain and related tools, and it will be published as
part of a public dataset.

For more details, see https://telemetry.go.dev/privacy.

			counter:   packetsReceivedPerSecondQuery,
			skipCheck: true,
		},
		"Net Adapter Packets Sent/sec Query": {
			counter:   packetsSentPerSecondQuery,
			skipCheck: true,
		},
		"Net Adapter Bytes Received/sec Query": {
			counter:   bytesReceivedPerSecondQuery,
			skipCheck: true,
		},
		"Net Adapter Bytes Sent/sec Query": {
			counter:   bytesSentPerSecondQuery,
			skipCheck: true,
		},

  private var failed = false

  /** Total number of pings sent by this web socket. */
  private var sentPingCount = 0

  /** Total number of pings received by this web socket. */
  private var receivedPingCount = 0

  /** Total number of pongs received by this web socket. */
  private var receivedPongCount = 0

  /** True if we have sent a ping that is still awaiting a reply. */
  private var awaitingPong = false

	responses <-chan Response
	cancel    context.CancelCauseFunc

	// Requests sent to the server.
	// If the handler is defined with 0 incoming capacity this will be nil.
	// Channel *must* be closed to signal the end of the stream.
	// If the request context is canceled, the stream will no longer process requests.
	// Requests sent cannot be used any further by the called.
	Requests chan<- []byte

	muxID uint64

	if abortIdle < 0 {
		return syscall.ENOPROTOOPT
	}
	if interval < 0 && count < 0 {
		abortIdle = -1
	}

	if abortIdle > 0 {
		// Note that the consequent probes will not be sent at equal intervals on Solaris,
		// but will be sent using the exponential backoff algorithm.
		err := fd.pfd.SetsockoptInt(syscall.IPPROTO_TCP, syscall.TCP_KEEPALIVE_ABORT_THRESHOLD, abortIdle)
		runtime.KeepAlive(fd)

    assert response.status_code == 200, response.text
    assert response.json() == {"message": "No file sent"}


def test_post_uploadfile_no_body():
    response = client.post("/uploadfile/")
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "No upload file sent"}


def test_post_file(tmp_path):
    path = tmp_path / "test.txt"
    path.write_bytes(b"<file content>")

    assert response.status_code == 200, response.text
    assert response.json() == {"message": "No file sent"}


@needs_py310
def test_post_uploadfile_no_body(client: TestClient):
    response = client.post("/uploadfile/")
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "No upload file sent"}


@needs_py310
def test_post_file(tmp_path: Path, client: TestClient):

        os.remove(log)  # pragma: no cover
    response = client.post("/send-notification/******@****.***?q=some-query")
    assert response.status_code == 200, response.text
    assert response.json() == {"message": "Message sent"}
    with open("./log.txt") as f:

		//     for this specific bookmark, and we even haven't received one.
		// (b) We have seen the bookmarkAfterResourceVersion, and it was sent already to the client.
		//     We can simply terminate the watcher.

		// we are graceful = true, when:
		//
		// (a) We have seen a bookmark, but it hasn't been sent to the client yet.
		//     That means we should drain the input buffer which contains

    email: str, background_tasks: BackgroundTasks, q: Annotated[str, Depends(get_query)]
):
    message = f"message to {email}\n"
    background_tasks.add_task(write_log, message)