.body("abc")
        .build(),
    )
    val ipAddress = InetAddress.getLoopbackAddress().hostAddress
    val call =
      client.newCallWithListener(
        Request
          .Builder()
          .url(
            server
              .url("/")
              .newBuilder()
              .host(ipAddress!!)
              .build(),
          ).build(),
      )

            <builds>
              <build path="$PROJECT_DIR$/build-logic" name="build-logic">
                <projects>
                  <project path="$PROJECT_DIR$/build-logic" />
                  <project path="$PROJECT_DIR$/build-logic/binary-compatibility" />
                  <project path="$PROJECT_DIR$/build-logic/build-init-samples" />
                  <project path="$PROJECT_DIR$/build-logic/build-update-utils" />

        .code(408)
        .build(),
    )
    webServer.enqueue(
      MockResponse
        .Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("abc")
    serverListener.assertTextMessage("abc")
    server.send("def")

        .build()
        .routeDatabase,
    )
    assertNotSame(
      client.routeDatabase,
      client
        .newBuilder()
        .proxySelector(proxySelector)
        .build()
        .routeDatabase,
    )
    assertNotSame(
      client.routeDatabase,
      client
        .newBuilder()
        .proxy(Proxy.NO_PROXY)
        .build()
        .routeDatabase,
    )
    assertNotSame(

    init {
        setArtifactRules(
            """
            **/build/git-checkout/platforms/core-runtime/base-services/build/generated-resources/build-receipt/org/gradle/build-receipt.properties
            **/build/git-checkout/build/distributions/*.zip => promote-build-distributions
            **/build/git-checkout/build/reports/integTest/** => distribution-tests
            **/build/releases-data-checkout/data/releases.xml

        assertEquals("test", pom.getValue("build/defaultGoal"));
        assertEquals("coreit", pom.getValue("build/finalName"));

        assertPathSuffixEquals("build", pom.getValue("build/directory"));
        assertPathSuffixEquals("build/main", pom.getValue("build/outputDirectory"));
        assertPathSuffixEquals("build/test", pom.getValue("build/testOutputDirectory"));

        configuration.setResolveDependencies(true);

        // single project build entry point
        ProjectBuildingResult result = getContainer()
                .lookup(org.apache.maven.project.ProjectBuilder.class)
                .build(pomFile, configuration);
        assertEquals(1, result.getProject().getArtifacts().size());
        // multi projects build entry point
        List<ProjectBuildingResult> results = getContainer()

        // Should have both consumer POM (no classifier) and build POM (with "build" classifier)
        Collection<Artifact> artifacts = result.getArtifacts();
        assertEquals(3, artifacts.size()); // original jar + consumer pom + build pom

        assertTrue(artifacts.stream().anyMatch(a -> "pom".equals(a.getExtension()) && "".equals(a.getClassifier())));

type Expression interface {
	Build(builder Builder)
}

// NegationExpressionBuilder negation expression builder
type NegationExpressionBuilder interface {
	NegationBuild(builder Builder)
}

// Expr raw expression
type Expr struct {
	SQL                string
	Vars               []interface{}
	WithoutParentheses bool
}

// Build build raw expression
func (expr Expr) Build(builder Builder) {

  }

  @Test
  fun proxy() {
    server.enqueue(MockResponse.Builder().body("abc").build())
    server.enqueue(MockResponse.Builder().body("def").build())
    val client =
      clientTestRule
        .newClientBuilder()
        .proxy(socksProxy.proxy())
        .build()
    val request1 = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request1).execute()