given:
        list.addAll(['a', 'b', 'c'])

        expect:
        def iter = list.listIterator()
        iter.hasNext()
        iter.next() == 'a'
        iter.hasNext()
        iter.next() == 'b'
        iter.hasNext()
        iter.next() == 'c'
        !iter.hasNext()
    }

    def "can remove element using ListIterator"() {
        given:
        list.addAll(['a', 'b', 'c'])

        then:
        source.iteratorNoFlush().collect() == ["buzz", "fizz", "fuzz"]

        when:
        while (iterator.hasNext()) {
            iterator.next()
            iterator.remove()
        }

        then:
        !iterator.hasNext()
        !iterator.hasPrevious()
        source.iteratorNoFlush().collect() == []
    }

    def "listIterator can add elements"() {

func TestLargeCosNovec(t *testing.T) {
	if !HasVX {
		t.Skipf("no vector support")
	}
	large := float64(100000 * Pi)
	for i := 0; i < len(vf); i++ {
		f1 := cosLarge[i]
		f2 := CosNoVec(vf[i] + large)
		if !close(f1, f2) {
			t.Errorf("Cos(%g) = %g, want %g", vf[i]+large, f2, f1)
		}
	}
}

func TestLargeSinNovec(t *testing.T) {
	if !HasVX {
		t.Skipf("no vector support")
	}

        }
        // 1.3-compatible.
        StringBuffer buffer = new StringBuffer();
        Iterator propertyValues = values.iterator();
        while (propertyValues.hasNext()) {
            buffer.append(propertyValues.next());
            if (propertyValues.hasNext()) {
                buffer.append(", ");
            }
        }
        connection.setRequestProperty(key, buffer.toString());
    }

// license that can be found in the LICENSE file.

#include "textflag.h"

TEXT ·archLog10(SB), NOSPLIT, $0
	MOVD ·log10vectorfacility+0x00(SB), R1
	BR   (R1)

TEXT ·log10TrampolineSetup(SB), NOSPLIT, $0
	MOVB   ·hasVX(SB), R1
	CMPBEQ R1, $1, vectorimpl                 // vectorfacility = 1, vector supported
	MOVD   $·log10vectorfacility+0x00(SB), R1
	MOVD   $·log10(SB), R2
	MOVD   R2, 0(R1)
	BR     ·log10(SB)

vectorimpl:

                in.nextNull();
                return null;
            }

            in.beginObject();
            String message = null;
            Throwable cause = null;
            while (in.hasNext()) {
                String name = in.nextName();
                switch (name) {
                    case "message": {
                        message = in.nextString();
                        break;

        while (actions.hasNext()) {
            InputChangesAwareTaskAction action = actions.next();
            task.getState().setDidWork(true);
            task.getStandardOutputCapture().start();
            boolean hasMoreWork = hasTaskListener || actions.hasNext();
            try {

        assertThat(header.length).isEqualTo(5L)
        assertThat(derReader.readOctetString()).isEqualTo("Jones".encodeUtf8())
      }

      assertThat(derReader.hasNext()).isFalse()
    }

    assertThat(derReader.hasNext()).isFalse()
  }

  @Test fun `encode tagged implicit prefixed type`() {
    // Type1 ::= VisibleString
    // Type2 ::= [APPLICATION 3] IMPLICIT Type1
    // Type3 ::= [2] Type2

    return new Iterator<E>() {
      @CheckForNull Map.Entry<E, Count> toRemove;

      @Override
      public boolean hasNext() {
        return backingEntries.hasNext();
      }

      @Override
      @ParametricNullness
      public E next() {
        final Map.Entry<E, Count> mapEntry = backingEntries.next();
        toRemove = mapEntry;

        CIFSContext ctx = withAnonymousCredentials();
        try ( SmbFile smbFile = new SmbFile("smb://", ctx) ) {
            try ( CloseableIterator<SmbResource> it = smbFile.children() ) {
                while ( it.hasNext() ) {
                    try ( SmbResource serv = it.next() ) {
                        System.err.println(serv.getName());
                    }
                }
            }
        }