// represents one TCP/UDP port.  A bitmap:port type of set can store up to 65535 ports.
	BitmapPort Type = "bitmap:port"
	// HashIP represents the `hash:ip` type ipset.
	HashIP Type = "hash:ip"
)

// DefaultPortRange defines the default bitmap:port valid port range.
const DefaultPortRange string = "0-65535"

const (
	// ProtocolFamilyIPV4 represents IPv4 protocol.

/**
 * @author koichik
 *
 */
public class MultiIteratorTest {

    /**
     *
     */
    @Test
    public void test() {
        final List<String> list1 = asList("Foo", "Bar");
        final List<String> list2 = asList("Baz");

        @SuppressWarnings("unchecked")
        final Iterator<String> it = new MultiIterator<String>(list1.iterator(), list2.iterator());

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

import java.util.Arrays;
import java.util.List;

public class ToolchainBuildOptions extends BuildOptionSet<ToolchainConfiguration> {
    private final List<? extends BuildOption<? super ToolchainConfiguration>> options = Arrays.asList(
        new JavaInstallationPathsOption(),
        new JavaInstallationEnvironmentPathsOption(),
        new AutoDetectionOption(),
        new AutoDownloadOption(),
        new IntellijJdkBuildOption()
    );

    Helpers.assertEqualIgnoringOrder(Arrays.asList(expected), Arrays.asList(actual));
  }

  private void expectArrayContentsInOrder(List<E> expected, Object[] actual) {
    assertEquals("toArray() ordered contents: ", expected, Arrays.asList(actual));
  }

  /**
   * Returns the {@link Method} instance for {@link #testToArray_isPlainObjectArray()} so that tests
   * of {@link Arrays#asList(Object[])} can suppress it with {@code

@GwtIncompatible // java.util.Arrays#copyOf(Object[], int), java.lang.reflect.Array
public class CompactHashSetTest extends TestCase {
  public static Test suite() {
    List<Feature<?>> allFeatures =
        Arrays.<Feature<?>>asList(
            CollectionSize.ANY,
            CollectionFeature.ALLOWS_NULL_VALUES,
            CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
            CollectionFeature.GENERAL_PURPOSE,

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.collect;

import static java.util.Arrays.asList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import com.google.common.collect.testing.AnEnum;

    Helpers.assertEqualIgnoringOrder(Arrays.asList(expected), Arrays.asList(actual));
  }

  private void expectArrayContentsInOrder(List<E> expected, Object[] actual) {
    assertEquals("toArray() ordered contents: ", expected, Arrays.asList(actual));
  }

  /**
   * Returns the {@link Method} instance for {@link #testToArray_isPlainObjectArray()} so that tests
   * of {@link Arrays#asList(Object[])} can suppress it with {@code

    private static final List<String> UNITS = unmodifiableList(asList(" B", " KiB", " MiB", " GiB", " TiB", " PiB", " EiB"));
    private static final List<String> ORDINAL_SUFFIXES = unmodifiableList(asList("th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"));


    /**
     * Percentage (0-...) of given input.
     *

    }

    private List<T> asList() {
        return Lists.newArrayList(listIterator());
    }

    @Override
    public T get(int index) {
        return asList().get(index);
    }

    @Override
    public int indexOf(Object o) {
        return asList().indexOf(o);
    }

    @Override
    public int lastIndexOf(Object o) {
        return asList().lastIndexOf(o);
    }

    @Override

        when:
        def result = set.containsAll(Arrays.asList('existing', 'other'))

        then:
        result
        1 * listener.onAccess('existing')
        1 * listener.onAccess('other')
        0 * listener._
    }

    def "containsAll of missing elements is tracked"() {
        when:
        def result = set.containsAll(Arrays.asList('missing', 'alsoMissing'))

        then:
        !result