if (x * i == n) return "${factor(x)} × $i"
          }
          return n.toString()
        }
      }

    val request =
      Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),
        body = requestBody,
      )

    client.newCall(request).execute().use { response ->
      if (!response.isSuccessful) throw IOException("Unexpected code $response")

      println(response.body.string())

type HandlerID uint8

const (
	// OpConnect is a connect request.
	OpConnect Op = iota + 1

	// OpConnectResponse is a response to a connect request.
	OpConnectResponse

	// OpPing is a ping request.
	// If a mux id is specified that mux is pinged.
	// Clients send ping requests.
	OpPing

	// OpPong is a OpPing response returned by the server.
	OpPong

    }

    @Override public Response intercept(Chain chain) throws IOException {
      Request request = chain.request();
      if (request.url().host().equals(host)) {
        request = request.newBuilder()
            .header("Authorization", credentials)
            .build();
      }
      return chain.proceed(request);
    }
  }

        assertEquals(123, request.tid);
    }

    @Test
    void testSendWithDfs() throws SmbException {
        SmbTree tree = new SmbTree(session, "testShare", "A:");
        tree.connectionState = 2; // Connected state
        tree.tid = 123;
        tree.inDfs = true;

        // Create request with path
        ServerMessageBlock request = new SmbComOpenAndX("\\testPath", 0x01, 0, null);

        String xml = new DefaultToolchainsXmlFactory().toXmlString(persistedToolchains.getDelegate());
        ToolchainsBuildingRequest request = new DefaultToolchainsBuildingRequest();
        request.setUserToolchainsSource(new StringSource(xml));

        ToolchainsBuildingResult result = toolchainBuilder.build(request);
        assertNotNull(result.getEffectiveToolchains());
        assertEquals(1, result.getEffectiveToolchains().getToolchains().size());

            this.session = request.getSession();
            this.trace = request.getTrace();
            this.requestType = request.getRequestType();
            this.locationTracking = request.isLocationTracking();
            this.recursive = request.isRecursive();
            this.source = request.getSource();
            this.profiles = request.getProfiles();

    call: Call,
    e: IOException,
  ) {
    responses.add(RecordedResponse(call.request(), null, null, null, e))
    (this as Object).notifyAll()
  }

  @Synchronized
  override fun onResponse(
    call: Call,
    response: Response,
  ) {
    val body = response.body.string()
    responses.add(RecordedResponse(call.request(), response, null, body, null))
    (this as Object).notifyAll()
  }

  /**

        // Arrange - generic return type respected
        when(tree.send(request)).thenReturn(response);

        // Act
        CommonServerMessageBlockResponse out = tree.send(request);

        // Assert
        assertSame(response, out);
        verify(tree).send(request);
    }

    @Test
    @DisplayName("send with multiple params returns the stubbed response")

                break;
            }

            if (request != null) {
                log.debug("Resetting request");
                request.reset();
            }
            if (rpath != null) {
                // resolveDfs() and tree.send() modify the request packet.
                // I want to restore it before retrying. request.reset()

        RdmaNegotiateRequest request = new RdmaNegotiateRequest();
        request.setMinVersion(0x0100);
        request.setMaxVersion(0x0100);
        request.setCreditsRequested(credits.getInitialCredits());
        request.setPreferredSendSize(maxReceiveSize);
        request.setMaxReceiveSize(maxReceiveSize);
        request.setMaxFragmentedSize(rdmaConnection.maxFragmentedSize);