/**
     * Get the value for the key 'mail.send.mock'. <br>
     * The value is, e.g. true <br>
     * comment: Does it send mock mail? (true: no send actually, logging only)
     * @return The value of found property. (NotNull: if not found, exception but basically no way)
     */
    String getMailSendMock();

    /**
     * Is the property for the key 'mail.send.mock' true? <br>
     * The value is, e.g. true <br>

                    req.setMaxDataCount(1024);
                }
                th.send(req, resp, RequestParam.NO_RETRY);
                return resp.getResponseLength();
            }
            if (this.call) {
                th.send(new TransWaitNamedPipe(th.getConfig(), this.uncPath), new TransWaitNamedPipeResponse(th.getConfig()));

		auditEntry := GetAuditEntry(ctx)
		if auditEntry != nil {
			entry = *auditEntry
		}
	}

	// Send audit logs only to http targets.
	for _, t := range auditTgts {
		if err := t.Send(ctx, entry); err != nil {
			LogOnceIf(ctx, "logging", fmt.Errorf("Unable to send audit event(s) to the target `%v`: %v", t, err), "send-audit-event-failure")
		}
	}

        when(tree.isSMB2()).thenReturn(true);
        when(tree.getConfig()).thenReturn(mock(Configuration.class));
        when(handle.getFileId()).thenReturn(fileId);
        when(tree.send(any(CommonServerMessageBlockRequest.class), any(), any(), any())).thenReturn(resp);
    }

    // Prepare SMB1 flow with a given response
    private void setupSmb1(NotifyResponse resp, int fid) throws Exception {

}

// Type - returns type of the target
func (sys *HTTPConsoleLoggerSys) Type() types.TargetType {
	return types.TargetConsole
}

// Send log message 'e' to console and publish to console
// log pubsub system
func (sys *HTTPConsoleLoggerSys) Send(ctx context.Context, entry any) error {
	var lg log.Info
	switch e := entry.(type) {
	case log.Entry:
		lg = log.Info{Entry: e, NodeName: sys.nodeName}

            return message

        return inner

    async def __call__(self, scope, receive, send):
        if scope["type"] != "http" or self.max_content_size is None:
            await self.app(scope, receive, send)
            return

        wrapper = self.receive_wrapper(receive)
        await self.app(scope, wrapper, send)


@router.post("/middleware")

    client.dispatcher().executorService().shutdown();
  }

  @Override public void onOpen(WebSocket webSocket, Response response) {
    webSocket.send("Hello...");
    webSocket.send("...World!");
    webSocket.send(ByteString.decodeHex("deadbeef"));
    webSocket.close(1000, "Goodbye, World!");
  }

  @Override public void onMessage(WebSocket webSocket, String text) {

     *            authentication). If false and the user has not been authenticated yet
     *            the client will be forced to send an authentication (server sends
     *            HttpServletResponse.SC_UNAUTHORIZED).
     * @return True if the negotiation is complete, otherwise false
     * @throws IOException if an I/O error occurs

run-name: Notify the IDE Experience team about new RCs for manual testing
on:
  push:
    tags:
      - 'v*.*.*-RC1'

permissions: {}

jobs:
  send-slack-notification:
    runs-on: ubuntu-latest
    steps:
      - name: Send Slack notification about new RCs for manual testing
        id: slack
        uses: slackapi/slack-github-action@v3.0.1
        with:

        if (len < 0) {
            len = 0;
        }

        if ((pipe.pipeType & SmbNamedPipe.PIPE_TYPE_CALL) == SmbNamedPipe.PIPE_TYPE_CALL) {
            pipe.send(new TransWaitNamedPipe(path), new TransWaitNamedPipeResponse());
            pipe.send(new TransCallNamedPipe(path, b, off, len), new TransCallNamedPipeResponse(pipe));
        } else if ((pipe.pipeType & SmbNamedPipe.PIPE_TYPE_TRANSACT) == SmbNamedPipe.PIPE_TYPE_TRANSACT) {