@Override
    public String getUserDomain() {
        if (this.realm == null && this.getSubject() != null) {
            Set<Principal> pr = this.getSubject().getPrincipals();
            for (Iterator<Principal> ite = pr.iterator(); ite.hasNext();) {
                try {
                    KerberosPrincipal entry = (KerberosPrincipal) ite.next();
                    return entry.getRealm();
                } catch (Exception e) {

            String key = "\\" + domain + "\\" + root;
            if (!path.equals("\\")) {
                key += path;
            }
            key = key.toLowerCase();

            final Iterator iter = referrals.map.keySet().iterator();
            while (iter.hasNext()) {
                final String _key = (String) iter.next();
                final int _klen = _key.length();
                boolean match = false;

import org.apache.commons.jxpath.ri.QName;
import org.apache.commons.jxpath.ri.model.NodeIterator;
import org.apache.commons.jxpath.ri.model.NodePointer;
import org.apache.maven.api.xml.XmlNode;

/**
 * An attribute iterator for JXPath to support <code>Xpp3Dom</code>.
 *
 */
class Xpp3DomAttributeIterator implements NodeIterator {

    private NodePointer parent;

    private XmlNode node;

                    }
                ]
            }
        """])

        then:
        changes.acceptedChanges.size() == 1
        def acceptedChange = changes.acceptedChanges.entrySet().iterator().next()
        def change = acceptedChange.key
        change.type == "org.gradle.api.initialization.ConfigurableIncludedBuild"
        change.member == "Implemented interface org.gradle.api.initialization.IncludedBuild"

    cache.evictAll()
  }

  /**
   * Returns an iterator over the URLs in this cache. This iterator doesn't throw
   * `ConcurrentModificationException`, but if new responses are added while iterating, their URLs
   * will not be returned. If existing responses are evicted during iteration, they will be absent
   * (unless they were already returned).
   *

        // only Project.A has no dependencies
        assertEquals(1, rootSchedulableBuilds.size());
        assertEquals(
                ProjectDependencyGraphStub.A, rootSchedulableBuilds.iterator().next());
        // double check A deps
        List<MavenProject> dependenciesA = graph.getDependencies(ProjectDependencyGraphStub.A);
        assertEquals(0, dependenciesA.size());

 * a single section.
 */
internal fun withoutSectionSpans(mappings: List<Mapping>): List<Mapping> {
  val result = mutableListOf<Mapping>()

  val i = mappings.iterator()
  var current = i.next()

  while (true) {
    if (current.spansSections) {
      result +=
        Mapping(
          current.sourceCodePoint0,
          current.section + 0x7f,

            return parent.isEmpty();
        }

        public boolean contains(final Object o) {
            return parent.contains(o);
        }

        public Iterator<E> iterator() {
            return parent.iterator();
        }

        public Object[] toArray() {
            return parent.toArray();
        }

        public <T> T[] toArray(final T[] a) {

   */
  @Synchronized
  fun await(url: HttpUrl): RecordedResponse {
    val timeoutMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime()) + TIMEOUT_MILLIS
    while (true) {
      val i = responses.iterator()
      while (i.hasNext()) {
        val recordedResponse = i.next()
        if (recordedResponse.request.url.equals(url)) {
          i.remove()
          return recordedResponse
        }
      }

        for (Method app : applicables) {
            Class<?>[] appArgs = app.getParameterTypes();
            boolean lessSpecific = false;

            for (Iterator<Method> maximal = maximals.iterator(); !lessSpecific && maximal.hasNext(); ) {
                Method max = maximal.next();

                switch (moreSpecific(appArgs, max.getParameterTypes())) {
                    case MORE_SPECIFIC: