*/
class ReactorModelPool {

    private final Map<CacheKey, File> pomFiles = new HashMap<>();

    public File get(String groupId, String artifactId, String version) {
        return pomFiles.get(new CacheKey(groupId, artifactId, version));
    }

    public void put(String groupId, String artifactId, String version, File pomFile) {
        pomFiles.put(new CacheKey(groupId, artifactId, version), pomFile);
    }

public class MavenArtifactRepository implements ArtifactRepository {
    private static final String LS = System.lineSeparator();

    private String id;

    private String url;

    private String basedir;

    private Path basedirPath;

    private String protocol;

    private ArtifactRepositoryLayout layout;

    private ArtifactRepositoryPolicy snapshots;

topic            (string)    Kafka topic used for bucket notifications
sasl_username    (string)    username for SASL/PLAIN or SASL/SCRAM authentication
sasl_password    (string)    password for SASL/PLAIN or SASL/SCRAM authentication
sasl_mechanism   (string)    sasl authentication mechanism, default 'PLAIN'
tls_client_auth  (string)    clientAuth determines the Kafka server's policy for TLS client auth

        }
    }

    public void scriptedMetric(String name, ConditionOptionCall<ScriptedMetricAggregationBuilder> opLambda) {
        ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {

    }

    public static class Artifact {
        private String groupId;

        private String artifactId;

        private String version;

        private String extension;

        private String classifier;

        public Artifact(String groupId, String artifactId, String version, String extension, String classifier) {
            this.groupId = groupId;

	testCases := []struct {
		queryParams map[string]string
		headers     map[string]string
		region      string
		expected    APIErrorCode
	}{
		// (0) Should error without a set URL query.
		{
			region:   globalMinioDefaultRegion,
			expected: ErrInvalidQueryParams,
		},
		// (1) Should error on an invalid access key.
		{
			queryParams: map[string]string{
				"X-Amz-Algorithm":     signV4Algorithm,

 */
public class InvalidArtifactRTException extends RuntimeException {

    private final String groupId;
    private final String artifactId;
    private final String version;
    private final String type;
    private final String baseMessage;

    public InvalidArtifactRTException(String groupId, String artifactId, String version, String type, String message) {
        this.groupId = groupId;
        this.artifactId = artifactId;

      Future<String> f = testExecutor.submit(doNothing(), RESULT_VALUE);
      mock.assertLastMethodCalled("submit");
      assertEquals(RESULT_VALUE, f.get());
    }
    {
      MockExecutor mock = new MockExecutor();
      TestExecutor testExecutor = new TestExecutor(mock);
      Callable<String> task = Callables.returning(RESULT_VALUE);
      Future<String> f = testExecutor.submit(task);

        private final String v3Phase;
        private final String v4Phase;

        DefaultAlias(String v3Phase, String v4Phase) {
            this.v3Phase = v3Phase;
            this.v4Phase = v4Phase;
        }

        @Override
        public String v3Phase() {
            return v3Phase;
        }

        @Override
        public String v4Phase() {
            return v4Phase;

  static class FactoryMethodAcceptsNull {

    final String name;

    private FactoryMethodAcceptsNull(String name) {
      this.name = name;
    }

    static FactoryMethodAcceptsNull create(@Nullable String name) {
      return new FactoryMethodAcceptsNull(name);
    }
  }

  static class FactoryMethodDoesNotAcceptNull {

    final String name;