private var peekedHeader: DerHeader? = null

  private val bytesLeft: Long
    get() = if (limit == -1L) -1L else (limit - byteCount)

  fun hasNext(): Boolean = peekHeader() != null

  /**
   * Returns the next header to process unless this scope is exhausted.
   *
   * This returns null if:
   *
   *  * The stream is exhausted.
   *  * We've read all of the bytes of an object whose length is known.

    assertEquals(expectedPermutation, permutations.next());
  }

  private <T> void assertNoMorePermutations(Iterator<List<T>> permutations) {
    assertFalse("Expected no more permutations, but there was one.", permutations.hasNext());
    try {
      permutations.next();
      fail("Expected NoSuchElementException.");
    } catch (NoSuchElementException expected) {
    }

        @Override
        public boolean hasNext() {
          checkForComodification();
          return nextEntry != ValueSet.this;
        }

        @Override
        @ParametricNullness
        public V next() {
          if (!hasNext()) {
            throw new NoSuchElementException();
          }
          ValueEntry<K, V> entry = (ValueEntry<K, V>) nextEntry;
          V result = entry.getValue();

        boolean matched = false;
        for (Iterator<String> i = patterns.iterator(); i.hasNext() & !matched; ) {
            // TODO what about wildcards? Just specifying groups? versions?
            if (id.equals(i.next())) {
                matched = true;
            }
        }
        return matched;
    }

    public List<String> getPatterns() {
        return new ArrayList<>(patterns);
    }

    @Override

        artifactDependencies = resolver.resolve( project, Collections.singleton( Artifact.SCOPE_RUNTIME ), session );
        assertEquals( 1, artifactDependencies.size() );
        assertEquals( "b", artifactDependencies.iterator().next().getArtifactId() );
    }
    */

    @Test
    void testSystemScopeDependencies() throws Exception {
        MavenSession session = createMavenSession(null);

        StringBuilder buffer = new StringBuilder("ManagedVersionMap (" + size() + " entries)\n");
        Iterator<String> iter = keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            buffer.append(key).append('=').append(get(key));
            if (iter.hasNext()) {
                buffer.append('\n');
            }
        }
        return buffer.toString();
    }

			log.Fatal(err)
		}
	}
	if err := tw.Close(); err != nil {
		log.Fatal(err)
	}

	// Open and iterate through the files in the archive.
	tr := tar.NewReader(&buf)
	for {
		hdr, err := tr.Next()
		if err == io.EOF {
			break // End of archive
		}
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("Contents of %s:\n", hdr.Name)
		if _, err := io.Copy(os.Stdout, tr); err != nil {
			log.Fatal(err)

    return new AbstractIterator<E>() {
      @Override
      @CheckForNull
      protected E computeNext() {
        while (entries.hasNext()) {
          Entry<E, ?> entry = entries.next();
          if (targetNode.equals(entry.getValue())) {
            return entry.getKey();
          }
        }
        return endOfData();
      }
    };
  }

  @Override

                    }
                ]
            }
        """])

        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"

            StringBuffer value = new StringBuffer();
            Iterator<String> values = property.getValue().iterator();
            while ( values.hasNext() ) {
                value.append(values.next());
                if ( values.hasNext() )
                    value.append(", ");
            }
            this.setRequestProperty(key, value.toString());
        }