} else {
					res, err = objAPI.HealObject(ctx, task.bucket, task.object, task.versionID, task.opts)
				}
			}

			if task.respCh != nil {
				task.respCh <- healResult{result: res, err: err}
				continue
			}

			// when respCh is not set caller is not waiting but we
			// update the relevant metrics for them
			if bgSeq != nil {
				if err == nil {
					bgSeq.countHealed(res.Type)

			return nil
		}
		// Don't wait for result
		return nil
	}

	// respCh must be set to wait for result.
	// We make it size 1, so a result can always be written
	// even if we aren't listening.
	task.respCh = make(chan healResult, 1)
	select {
	case globalBackgroundHealRoutine.tasks <- task:
		if serverDebugLog {

		} else {
			writeSuccessResponseJSON(w, respBytes)
		}
		return
	}

	respCh := make(chan healResp, 1)
	switch {
	case hip.forceStop:
		go func() {
			respBytes, apiErr := globalAllHealState.stopHealSequence(healPath)
			hr := healResp{respBytes: respBytes, apiErr: apiErr}
			respCh <- hr
		}()
	case hip.clientToken == "":

        byte command = (byte) 0x25;
        byte subcommand = (byte) 0x01;
        TestSmbComTransactionResponse resp = new TestSmbComTransactionResponse(mockConfig, command, subcommand);
        assertNotNull(resp);
        assertEquals(command, resp.getCommand());
        assertEquals(subcommand, resp.getSubCommand());
    }

    @Test
    @DisplayName("Test dataCount getter and setter")
    void testDataCountGetterSetter() {

				m.addErrorNonBlockingClose(respHandler, err)
			}
			return
		case resp, ok := <-respServer:
			if !ok {
				return
			}
		sendResp:
			select {
			case respHandler <- resp:
				m.respMu.Lock()
				if !m.closed {
					gridLogIf(m.ctx, m.sendLocked(message{Op: OpUnblockSrvMux, MuxID: m.MuxID}))
				}
				m.respMu.Unlock()
			case <-m.ctx.Done():
				// Client canceled. Don't block.

	case debugIsOutgoingClosed:
		// params: muxID uint64, isClosed func(bool)
		muxID, _ := args[0].(uint64)
		resp, _ := args[1].(func(b bool))
		mid, ok := c.outgoing.Load(muxID)
		if !ok || mid == nil {
			resp(true)
			return
		}
		mid.respMu.Lock()
		resp(mid.closed)
		mid.respMu.Unlock()
	case debugBlockInboundMessages:
		c.connMu.Lock()
		a, _ := args[0].(chan struct{})

        Smb2IoctlResponse resp = new Smb2IoctlResponse(config);

        resp.decode(packet, 0);
        assertEquals(Smb2IoctlRequest.FSCTL_SRV_COPYCHUNK, resp.getCtlCode());
        assertEquals(0x1234, resp.getIoctlFlags());
        assertNotNull(resp.getFileId());
        assertEquals(16, resp.getFileId().length);
        assertEquals(12, resp.getOutputLength());

        // Arrange
        TransWaitNamedPipeResponse resp = new TransWaitNamedPipeResponse();
        // Act & Assert - no exceptions should be thrown
        assertDoesNotThrow(() -> resp.writeSetupWireFormat(null, 0));
        assertDoesNotThrow(() -> resp.writeParametersWireFormat(null, 0));
        assertDoesNotThrow(() -> resp.writeDataWireFormat(null, 0));
        assertDoesNotThrow(() -> resp.readSetupWireFormat(null, 0, 0));

    client = TestClient(app)
    resp = client.get(
        "/query",
        params={
            "param": "123",
            "param2": "456",
        },
    )
    assert resp.status_code == 200
    assert resp.json() == {
        "param": "123",
        "param2": "456",
    }


def test_header_pass_extra_list():
    client = TestClient(app)

    resp = client.get(
        "/header",

            Trans2FindFirst2Response resp = inv.getArgument(1);
            setField(resp, jcifs.internal.smb1.trans.SmbComTransactionResponse.class, "results", new FileEntry[] { new FE("x") });
            setField(resp, Trans2FindFirst2Response.class, "sid", 7);
            setField(resp, jcifs.internal.smb1.trans.SmbComTransactionResponse.class, "status", 0);
            resp.received();
            return resp;
        });