""";

            Document document = new Parser().parse(pomXml);
            ModelVersionUtils.updateModelVersion(document, targetVersion);
            Element root = document.root();
            Element modelVersionElement = root.child("modelVersion").orElse(null);
            assertEquals(targetVersion, modelVersionElement.textContentTrimmed());
        }

        @ParameterizedTest(name = "to target version {0}")

    try (FileSystem fs = Jimfs.newFileSystem(Configuration.unix())) {
      Path root = fs.getRootDirectories().iterator().next();
      assertThat(root.getParent()).isNull();
      assertThat(root.toRealPath().getParent()).isNull();
      MoreFiles.createParentDirectories(root); // test that there's no exception
    }
  }

        buildFile = new File(testProjectDir.root, 'cloned/build.gradle')
        settingsFile = new File(testProjectDir.root, 'cloned/settings.gradle')
    }

    File setupGitRemote() {
        URL fakeRemote = getClass().getResource("fake_git/remote")
        File workingRemoteGit = new File(remoteRepoDirs.root, 'remote')

starting with its own and including everything up-to but not including the root. We don't need to
include root certificates because the client already has them.

```java
HandshakeCertificates serverHandshakeCertificates = new HandshakeCertificates.Builder()
    .heldCertificate(serverCertificate, intermediateCertificate.certificate())
    .build();
```

The client only needs to know the trusted root certificate. It checks the server's certificate by

            prefix = prefix.replace(':', '_');
        }
        File root = root(project);
        if (eclipseProject.getName().startsWith(prefix)) {
            licenseHeaderFile = new File(root, "build-tools-internal/src/main/resources/license-headers/elastic-license-2.0-header.txt");
        } else {
            licenseHeaderFile = new File(root, "build-tools-internal/src/main/resources/license-headers/sspl+elastic-license-header.txt");

                            "Failed to read documentation for expression root: " + root, e);
                } catch (XmlPullParserException e) {
                    throw new ExpressionDocumentationException(
                            "Failed to parse documentation for expression root: " + root, e);
                }
            }
        }

        return expressionDocumentation;
    }

```sh
curl -sSL --tlsv1.2 \
     -O 'https://raw.githubusercontent.com/minio/kes/master/root.key' \
     -O 'https://raw.githubusercontent.com/minio/kes/master/root.cert'
```

### 2. Set the MinIO-KES configuration

```sh
export MINIO_KMS_KES_ENDPOINT=https://play.min.io:7373
export MINIO_KMS_KES_KEY_FILE=root.key
export MINIO_KMS_KES_CERT_FILE=root.cert
export MINIO_KMS_KES_KEY_NAME=my-minio-key
```

### 3. Start the MinIO Server

  val clientBuilder =
    OkHttpClient.Builder().connectionSpecs(listOf(ConnectionSpec.CLEARTEXT)).dns {
      throw UnknownHostException("shortcircuit")
    }

  val request = Request("http://google.com/robots.txt".toHttpUrl())

  @Test
  fun testHttpLoggingInterceptor() {
    val interceptor =
      HttpLoggingInterceptor().apply {
        level = HttpLoggingInterceptor.Level.BASIC
      }

        @Test
        void rootUrlIsRoot() throws Exception {
            DummySmbResourceLocator root = new DummySmbResourceLocator("smb://server/");
            // last component includes trailing slash per specification
            assertEquals("server/", root.getName());
            assertEquals("smb://", root.getParent());
            assertTrue(root.isRoot());
        }

        @Test

                            XmlNode root = XmlService.read(is, null);
                            String groupId = mayGetChild(root, "groupId");
                            String artifactId = mayGetChild(root, "artifactId");
                            String goalPrefix = mayGetChild(root, "goalPrefix");
                            String name = mayGetChild(root, "name");