*/
@GwtCompatible
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
public class MultimapForEachTester<K, V> extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testForEach() {
    List<Entry<K, V>> entries = new ArrayList<>();
    multimap().forEach((k, v) -> entries.add(mapEntry(k, v)));
    assertEqualIgnoringOrder(getSampleElements(), multimap().entries());
  }

        assertThat(indexed3.getElement(), is("ccc"));

        assertThat(it.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testForEach() throws Exception {
        final List<String> list = newArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        for (final Indexed<String> indexed : indexed(list)) {

        assertThat(it.next(), is("ccc"));
        assertThat(it.hasNext(), is(not(true)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testForEach() throws Exception {
        final StringReader reader = new StringReader("aaa\nbbb\nccc\n");
        for (final String line : LineIterator.iterable(reader)) {
            System.out.println(line);
        }
    }

				t.Errorf("unexpected error: %v", err)
			}

			if m.Has(offset) {
				t.Errorf("expect offset %v not allocated", offset)
			}
		})
	}

}

func TestForEach(t *testing.T) {
	testCases := []struct {
		name      string
		allocator func(max int, rangeSpec string, reserved int) *AllocationBitmap
		max       int
		reserved  int
	}{
		{

    assertThat(ImmutableLongArray.of(13).contains(13)).isTrue();
    assertThat(ImmutableLongArray.of().contains(21)).isFalse();
    assertThat(iia.subArray(1, 5).contains(1)).isTrue();
  }

  public void testForEach() {
    ImmutableLongArray.of().forEach(i -> fail());
    ImmutableLongArray.of(0, 1, 3).subArray(1, 1).forEach(i -> fail());

    AtomicLong count = new AtomicLong(0);
    ImmutableLongArray.of(0, 1, 2, 3)

	}
	if _, err := r.AllocateNext(); err != nil {
		t.Error(err)
	}
	if f := r.Free(); f != 0 {
		t.Errorf("expected free equal to 0 got: %d", f)
	}
}

func TestForEach(t *testing.T) {
	pr, err := net.ParsePortRange("10000-10200")
	if err != nil {
		t.Fatal(err)
	}

	testCases := []sets.Int{
		sets.NewInt(),
		sets.NewInt(10000),
		sets.NewInt(10000, 10200),

    assertThat(ImmutableDoubleArray.of(13).contains(13)).isTrue();
    assertThat(ImmutableDoubleArray.of().contains(21)).isFalse();
    assertThat(iia.subArray(1, 5).contains(1)).isTrue();
  }

  public void testForEach() {
    ImmutableDoubleArray.of().forEach(i -> fail());
    ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).forEach(i -> fail());

    AtomicInteger count = new AtomicInteger(0);
    ImmutableDoubleArray.of(0, 1, 2, 3)

		}
	}

	if f := r.Free(); f != 0 {
		t.Errorf("expected free equal to 0 got: %d", f)
	}

	if r.max != 2 {
		t.Fatalf("expected range equal to 2, got: %v", r)
	}
}

func TestForEach(t *testing.T) {
	_, cidr, err := netutils.ParseCIDRSloppy("192.168.1.0/24")
	if err != nil {
		t.Fatal(err)
	}

	testCases := []sets.String{
		sets.NewString(),
		sets.NewString("192.168.1.1"),

  public void testExternalCompanionObject() {
    runTest("analysis/analysis-api/testData/components/resolver/singleByPsi/ExternalCompanionObject.kt");
  }

  @Test
  @TestMetadata("forEach.kt")
  public void testForEach() {
    runTest("analysis/analysis-api/testData/components/resolver/singleByPsi/forEach.kt");
  }

  @Test
  @TestMetadata("functionCall.kt")
  public void testFunctionCall() {

  public void testExternalCompanionObject() {
    runTest("analysis/analysis-api/testData/components/resolver/singleByPsi/ExternalCompanionObject.kt");
  }

  @Test
  @TestMetadata("forEach.kt")
  public void testForEach() {
    runTest("analysis/analysis-api/testData/components/resolver/singleByPsi/forEach.kt");
  }

  @Test
  @TestMetadata("functionCall.kt")
  public void testFunctionCall() {