return priority;
    }

    public void setPriority(final int priority) {
        this.priority = priority;
    }

    public void register() {
        ComponentUtil.getIngestFactory().add(this);
    }

    // web/file
    public ResultData process(final ResultData target, final ResponseData responseData) {
        return target;
    }

    // web/file

      try {
        tearDown.tearDown();
      } catch (Throwable t) {
        if (suppressThrows) {
          logger.log(Level.INFO, "exception thrown during tearDown", t);
        } else {
          exceptions.add(t);
        }
      }
    }
    if (!suppressThrows && (exceptions.size() > 0)) {
      throw ClusterException.create(exceptions);
    }
  }

 * <li>Information needed to find the artifact file in a repository including extension and classifier</li>
 * <li>Information on how to use the artifact as a dependency: whether to add it to the classpath, whether to load its
 * dependencies transitively</li>
 * </ul>
 *
 */
public interface ArtifactHandler {
    @Deprecated
    String ROLE = ArtifactHandler.class.getName();

    /**

    // -----------/
    // - Methods -/
    // -----------/

    /**
     * Method addPhase.
     *
     * @param phase a phase object.
     */
    public void addPhase(Phase phase) {
        getPhases().add(phase);
    } // -- void addPhase( Phase )

    /**
     * Get the ID of this lifecycle, for identification in the mojo
     * descriptor.
     *
     * @return String
     */
    public String getId() {

      try {
        tearDown.tearDown();
      } catch (Throwable t) {
        if (suppressThrows) {
          logger.log(Level.INFO, "exception thrown during tearDown", t);
        } else {
          exceptions.add(t);
        }
      }
    }
    if (!suppressThrows && (exceptions.size() > 0)) {
      throw ClusterException.create(exceptions);
    }
  }

    assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());
    assertEquals("b", iterator.next());
    assertEquals("b", iterator.previous());
    assertThrows(UnsupportedOperationException.class, () -> iterator.add("c"));
  }

  @SuppressWarnings("DoNotCall")
  public void testSet() {
    ListIterator<String> iterator = create();

    assertTrue(iterator.hasNext());
    assertEquals("a", iterator.next());

    index: Int,
  ): InetAddress {
    return hostAddresses[hostname]!![index]
  }

  @Throws(UnknownHostException::class)
  override fun lookup(hostname: String): List<InetAddress> {
    requestedHosts.add(hostname)
    return hostAddresses[hostname] ?: throw UnknownHostException()
  }

  fun assertRequests(vararg expectedHosts: String?) {
    assertThat(requestedHosts).containsExactly(*expectedHosts)

    }

    @Override
    public List<String> getAnnotationTypeNames() {
        return annotationNames;
    }

    public void addAnnotationTypeName(String annotationType) {
        annotationNames.add(annotationType);
    }

    @Override
    public boolean isDeprecated() {
        return annotationNames.contains(Deprecated.class.getName());
    }

    @Override
    public boolean isIncubating() {

  }

  @Test
  fun headersBuilder() {
    var builder: Headers.Builder = Headers.Builder()
    builder = builder.add("")
    builder = builder.add("", "")
    builder = builder.addUnsafeNonAscii("", "")
    builder = builder.addAll(headersOf())
    builder = builder.add("", Date(0L))
    builder = builder.add("", Instant.EPOCH)
    builder = builder.set("", "")
    builder = builder.set("", Date(0L))

				}
				for _, addr := range addrs {
					domainIPs.Add(addr)
				}
			}
			domainIPs.Add(endpoint)
		}
		updateDomainIPs(domainIPs)
	} else {
		// Add found interfaces IP address to global domain IPS,
		// loopback addresses will be naturally dropped.
		domainIPs := mustGetLocalIP4()
		for _, host := range globalEndpoints.Hostnames() {
			domainIPs.Add(host)
		}
		updateDomainIPs(domainIPs)
	}