<scm>
    <url>scm-url</url>
  </scm>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>maven-test</groupId>
        <artifactId>t05-b</artifactId>
        <version>1.0</version>
      </dependency>
      <dependency>
        <groupId>maven-test</groupId>
        <artifactId>t05-d</artifactId>
        <version>1.0</version>
      </dependency>
    </dependencies>

  }

  @Test fun setInstant() {
    val expected = Instant.ofEpochMilli(1000L)
    val headers =
      Headers.Builder()
        .add("Test-Instant", Instant.ofEpochMilli(0L))
        .set("Test-Instant", expected)
        .build()
    assertThat(headers["Test-Instant"]).isEqualTo("Thu, 01 Jan 1970 00:00:01 GMT")
    assertThat(headers.getInstant("Test-Instant")).isEqualTo(expected)
  }

		{[]string{"abcd/foo/bar/", "abcd/foo/bar/zoo"}, "abcd/foo/bar/"},
	}

	for i, test := range testCases {
		foundPrefix := lcp(test.prefixes, true)
		if foundPrefix != test.commonPrefix {
			t.Fatalf("Test %d: Common prefix found: `%v`, expected: `%v`", i+1, foundPrefix, test.commonPrefix)
		}
	}
}

func TestGetMinioMode(t *testing.T) {
	testMinioMode := func(expected string) {

        assertTrue(result.getErrors().get(0).contains("test:"));
    }

    @Test
    void testMissingPluginDependencyVersion() throws Exception {
        SimpleProblemCollector result = validate("missing-plugin-dependency-version.xml");

        assertViolations(result, 0, 1, 0);

        assertTrue(result.getErrors().get(0).contains("test:a"));
    }

    @Test

}

TEST(CAPI, RemoteExecuteSilentCopies) {
  TestRemoteExecuteSilentCopiesOp(/*async=*/false, /*remote=*/true);
}
TEST(CAPI, RemoteExecuteSilentCopiesAsync) {
  TestRemoteExecuteSilentCopiesOp(/*async=*/true, /*remote=*/true);
}
TEST(CAPI, RemoteExecuteSilentCopiesLocal) {
  TestRemoteExecuteSilentCopiesOp(/*async=*/false, /*remote=*/false);
}
TEST(CAPI, RemoteExecuteSilentCopiesLocalAsync) {

        String test = expectedVersion;
        boolean reverse = false;
        final boolean result;
        if (test.startsWith(REGEX_PREFIX)) {
            result = actualVersion.matches(test.substring(REGEX_PREFIX.length()));
        } else {
            if (test.startsWith("!")) {
                reverse = true;
                test = test.substring(1);
            }

// streamz->GetCell("label-value")->IncrementBy(1);
//
// The test code can then read and test the value of that counter:
//
// auto* reader = TFE_MonitoringNewCounterReader("name");
// test();
// int64_t value = TFE_MonitoringReadCounter1(reader, "label-value");

// Opaque handle to a reader.
typedef struct TFE_MonitoringCounterReader TFE_MonitoringCounterReader;

test-delete-replication:
	@(env bash $(PWD)/docs/bucket/replication/delete-replication.sh)

test-delete-marker-proxying:
	@(env bash $(PWD)/docs/bucket/replication/test_del_marker_proxying.sh)

test-replication: install-race test-replication-2site test-replication-3site test-delete-replication test-sio-error test-delete-marker-proxying ## verify multi site replication
	@echo "Running tests for replicating three sites"

                false);
        assertNotNull(res.get());
    }

    /**
     * This test has
     *   - a dependency directly managed to 0.2
     *   - then a BOM import which manages that same dep to 0.1
     * This <i>currently</i> results in 0.2 and a no warning
     */
    @Test
    void testManagedDependencyBeforeImport() throws Exception {

      )
      .build()
  }

  private fun buildServerSslSocketFactory(): SSLSocketFactory {
    // The test uses JDK default SSL Context instead of the Platform provided one
    // as Conscrypt seems to have some differences, we only want to test client side here.
    return try {
      val keyManager =
        newKeyManager(
          null,
          serverCert,