Java Examples for java.util.Iterator

public void testProposalsWithFieldAndParam() throws Exception {
    String template = evaluateTemplateInMethodWithField("void method(Collection<String> strings)", "Collection<Number> numbers");
    assertEquals("	for (java.util.Iterator iterator = strings.iterator(); iterator.hasNext();) {\n" + "		String string = (String) iterator.next();\n" + "		\n" + "	}", template);
}

public static UIComponent findComponent(UIComponent parent, String id) {
    if (id.equals(parent.getId())) {
        return parent;
    }
    Iterator<UIComponent> kids = parent.getFacetsAndChildren();
    while (kids.hasNext()) {
        UIComponent kid = kids.next();
        UIComponent found = findComponent(kid, id);
        if (found != null) {
            return found;
        }
    }
    return null;
}

public static String format(ArrayList<VideoFilter> listFilters) {
    StringBuffer result = new StringBuffer();
    Iterator<VideoFilter> it = listFilters.iterator();
    VideoFilter vf;
    while (it.hasNext()) {
        vf = it.next();
        result.append(vf.getFilterString());
        if (it.hasNext())
            result.append(",");
    }
    return result.toString();
}

public static String format(ArrayList<VideoFilter> listFilters) {
    StringBuffer result = new StringBuffer();
    Iterator<VideoFilter> it = listFilters.iterator();
    VideoFilter vf;
    while (it.hasNext()) {
        vf = it.next();
        result.append(vf.getFilterString());
        if (it.hasNext())
            result.append(",");
    }
    return result.toString();
}

public Object[][] convert(Map<String, Object> mapIn) {
    Object[][] out = new Object[mapIn.size()][2];
    Iterator<String> keyIterator = mapIn.keySet().iterator();
    Iterator<Object> valueIterator = mapIn.values().iterator();
    int row = 0;
    while (keyIterator.hasNext()) {
        //
        String key = keyIterator.next();
        Object value = valueIterator.next();
        out[row][0] = key;
        out[row][1] = value;
        row++;
    }
    return out;
}

public LocalRepository getLocalRepositoryOrFail() {
    Iterator<LocalRepository> repositoryIterator = pm().getExtent(LocalRepository.class).iterator();
    if (!repositoryIterator.hasNext()) {
        throw new IllegalStateException("LocalRepository entity not found in database.");
    }
    LocalRepository localRepository = repositoryIterator.next();
    if (repositoryIterator.hasNext()) {
        throw new IllegalStateException("Multiple LocalRepository entities in database.");
    }
    return localRepository;
}

public static String format(ArrayList<VideoFilter> listFilters) {
    StringBuffer result = new StringBuffer();
    Iterator<VideoFilter> it = listFilters.iterator();
    VideoFilter vf;
    while (it.hasNext()) {
        vf = it.next();
        result.append(vf.getFilterString());
        if (it.hasNext())
            result.append(",");
    }
    return result.toString();
}

public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append(name).append('(');
    Iterator<Object> iter = args.iterator();
    if (iter.hasNext()) {
        sb.append(JsonUtil.toJsonScriptCode(iter.next()));
    }
    for (; iter.hasNext(); ) {
        sb.append(',');
        sb.append(JsonUtil.toJsonScriptCode(iter.next()));
    }
    return sb.toString();
}

public static String getQualifiedString(List<String> nameList) {
    StringBuilder qualifiedname = new StringBuilder();
    for (Iterator<String> iterator = nameList.iterator(); iterator.hasNext(); ) {
        String string = iterator.next();
        qualifiedname.append(string);
        if (iterator.hasNext()) {
            qualifiedname.append("::");
        }
    }
    return qualifiedname.toString();
}

@Test
public void shouldHaveOrderOnCMTypes() {
    Iterator<CMType> cmTypeIterator = CMTypeManager.getInstance().getAllCMTypes().iterator();
    assertEquals("terminologies", cmTypeIterator.next().getId());
    assertEquals("archetypes", cmTypeIterator.next().getId());
    assertEquals("templates", cmTypeIterator.next().getId());
    assertEquals("guidelines", cmTypeIterator.next().getId());
}

public static Renderable findHtmlRenderable(RCollection root) {
    final Iterator<? extends Renderable> rs = root.getRenderables();
    if (rs != null) {
        while (rs.hasNext()) {
            final Renderable r = rs.next();
            if (r.getModelNode() instanceof HTMLHtmlElement) {
                return r;
            }
        }
    }
    return null;
}

/*
	 * (non-Javadoc)
	 * 
	 * @see java.util.Iterator#next()
	 */
@Override
public E next() {
    if (!hasNext()) {
        throw new NoSuchElementException();
    }
    // Get iterator
    Iterator<? extends E> itr = iterators.element();
    // Store next object
    E next = itr.next();
    // Store remove reference
    removePtr = itr;
    // Empty now ?
    if (!itr.hasNext()) {
        iterators.remove();
    }
    // Return the next
    return next;
}

public static void assertIteratorContainsExactly(String reason, Iterator<?> iterator, int expectedAmountOfElements) {
    int actualAmountOfElements = 0;
    while (iterator.hasNext() && actualAmountOfElements <= expectedAmountOfElements) {
        actualAmountOfElements++;
        iterator.next();
    }
    if (actualAmountOfElements != expectedAmountOfElements) {
        throw new ComparisonFailure(reason, Integer.toString(expectedAmountOfElements), Integer.toString(actualAmountOfElements));
    }
}

public static PostParameter[] mapToArray(Map<String, String> map) {
    PostParameter[] parList = new PostParameter[map.size()];
    Iterator<String> iter = map.keySet().iterator();
    int i = 0;
    while (iter.hasNext()) {
        String key = iter.next();
        String value = map.get(key);
        parList[i++] = new PostParameter(key, value);
    }
    return parList;
}

public static Iterator<EObject> allParents(final EObject eObject) {
    return new Iterator<EObject>() {

        EObject current = eObject;

        public boolean hasNext() {
            return current.eContainer() != null;
        }

        public EObject next() {
            current = current.eContainer();
            return current;
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    };
}

@Test
public void shouldStopAtLimitTest() {
    // Given
    Iterator<Integer> generator = new GeneratorFactory(new RandomDataGeneratorFactory()).uniform(1, 10);
    Iterator<Integer> cappedGenerator = new LimitGenerator<Integer>(generator, 10);
    // When
    int count = 0;
    while (cappedGenerator.hasNext()) {
        cappedGenerator.next();
        count++;
    }
    // Then
    assertEquals(10, count);
}

@java.lang.SuppressWarnings("all")
public Iterable<String> test() {
    class $YielderTest implements java.util.Iterator<String>, java.lang.Iterable<String>, java.io.Closeable {

        private boolean b;

        private int $state;

        private boolean $hasNext;

        private boolean $nextDefined;

        private String $next;

        private $YielderTest() {
            super();
        }

        public java.util.Iterator<String> iterator() {
            if (($state == 0)) {
                $state = 1;
                return this;
            } else
                return new $YielderTest();
        }

        public boolean hasNext() {
            if ((!$nextDefined)) {
                $hasNext = getNext();
                $nextDefined = true;
            }
            return $hasNext;
        }

        public String next() {
            if ((!hasNext())) {
                throw new java.util.NoSuchElementException();
            }
            $nextDefined = false;
            return $next;
        }

        public void remove() {
            throw new java.lang.UnsupportedOperationException();
        }

        public void close() {
            $state = 5;
        }

        private boolean getNext() {
            while (true) switch($state) {
                case 0:
                    ;
                    $state = 1;
                case 1:
                    ;
                    b = true;
                case 2:
                    ;
                    if ((!b)) {
                        $state = 3;
                        continue;
                    }
                    $next = "foo";
                    $state = 4;
                    return true;
                case 3:
                    ;
                    $next = "bar";
                    $state = 4;
                    return true;
                case 4:
                    ;
                    b = (!b);
                    $state = 2;
                    continue;
                case 5:
                    ;
                default:
                    ;
                    return false;
            }
        }
    }
    return new $YielderTest();
}

@Test
public void itShouldIterateSequenceUrls() throws Exception {
    Iterator<Sequence> it = new SequenceIterator(Granularity.hour, 999, 1001);
    assertEquals("http://planet.openstreetmap.org/replication/hour/000/001/000.osc.gz", it.next().getUrl());
    assertEquals("http://planet.openstreetmap.org/replication/hour/000/001/001.osc.gz", it.next().getUrl());
    assertFalse(it.hasNext());
}

@DataProvider(name = "dp")
public Iterator<Object[]> createData() {
    return new Iterator<Object[]>() {

        int count = 0;

        public boolean hasNext() {
            return count < 10;
        }

        public Object[] next() {
            if (++count == 6) {
                throw new RuntimeException();
            }
            return new Object[] { count };
        }

        public void remove() {
        }
    };
}

/**
	 * Does the given entity have the specified potion effect? <p>
	 * 
	 * Args: entity, potionEffect.
	 */
public static boolean doesMobHavePotionEffect(EntityLivingBase mob, Potion potion) {
    Iterator<?> iterator = mob.getActivePotionEffects().iterator();
    while (iterator.hasNext()) {
        PotionEffect effect = (PotionEffect) iterator.next();
        String eName = effect.getEffectName();
        if (eName.matches(potion.getName())) {
            return true;
        } else {
            continue;
        }
    }
    return false;
}

@Override
public Iterator<T> iterator() {
    return new Iterator<T>() {

        @Override
        public boolean hasNext() {
            return false;
        }

        @Override
        public T next() {
            throw new IllegalStateException("No element");
        }

        @Override
        public void remove() {
            throw new IllegalStateException("Remove not implemented");
        }
    };
}

public static void main(String[] args) {
    final String[] array = new String[] { "Frühjahr", "Sommer", "Herbst", "Winter", "Weihnachten", "Ostern", "Klausurwoche", "Fasching", "Geburtstag", "The day after the party" };
    Iterator<String> all = new EndlessSummer();
    //		Iterator<String> all = new RandomOrderArrayIterator<>(array);
    while (all.hasNext()) {
        System.out.println(all.next());
    }
}

public static void main(String args[]) {
    ArrayList names = CabUtil.parseCommandLine(args);
    if (names.size() < 1)
        names.add(".");
    Iterator i = names.iterator();
    while (i.hasNext()) {
        String cabName = (String) i.next();
        Cabinet cabinet = CabUtil.getCabinet(cabName);
        CabUtil.printCabinet(cabinet);
    }
}

public void testNodesFromSurt() {
    Iterator<SurtNode> it = SurtNode.nodesFromSurt("(org,archive,)/about").iterator();
    assertEquals("(", it.next().getName());
    assertEquals("(org,", it.next().getSurt());
    assertEquals("archive,", it.next().getName());
    assertEquals("(org,archive,)/", it.next().getSurt());
    assertEquals("about", it.next().getName());
    assertFalse(it.hasNext());
}

public void test1_discoveredNPETest() {
    // it used to fail when internal iterator was not present, due to NullPointerException
    List<Iterator<Object>> iterators = new ArrayList<Iterator<Object>>();
    FlattenedIterator<Object> it = new FlattenedIterator<>(iterators.iterator());
    while (it.hasNext()) {
        it.next();
    }
}

public static PostParameter[] mapToArray(Map<String, String> map) {
    PostParameter[] parList = new PostParameter[map.size()];
    Iterator<String> iter = map.keySet().iterator();
    int i = 0;
    while (iter.hasNext()) {
        String key = iter.next();
        String value = map.get(key);
        parList[i++] = new PostParameter(key, value);
    }
    return parList;
}

/**
   * Provides an {@link java.util.Iterator} backed by functional interfaces.
   * {@link java.util.Iterator#remove} is not supported.
   *
   * @param hasNext used to implement {@link java.util.Iterator#hasNext()}
   * @param next used to implement {@link java.util.Iterator#next()}
   * @param <E> the generic type
   * @return a new instance
   */
public static <E> Iterator<E> iterator(BooleanSupplier hasNext, Supplier<E> next) {
    Objects.requireNonNull(hasNext, "hasNext");
    Objects.requireNonNull(next, "next");
    class LambdaIterator extends BaseIterator<E> {

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

        @Override
        protected E nextElement() {
            return next.get();
        }
    }
    return new LambdaIterator();
}

@Override
public void setUp() {
    list1 = new ArrayList<java.lang.String>();
    list1.add("One");
    list1.add("Two");
    list1.add("Three");
    list2 = new ArrayList<java.lang.String>();
    list2.add("Four");
    list3 = new ArrayList<java.lang.String>();
    list3.add("Five");
    list3.add("Six");
    iteratorList = new ArrayList<java.util.Iterator<java.lang.String>>();
    iteratorList.add(list1.iterator());
    iteratorList.add(list2.iterator());
    iteratorList.add(list3.iterator());
}

protected final void fireShortDescriptionChange(String newShortDescription) {
    if (!hasListeners())
        return;
    synchronized (eventListeners) {
        java.util.Iterator iterator = eventListeners.iterator();
        while (iterator.hasNext()) {
            ((NodeUpdaterListener) iterator.next()).shortDescriptionChanged(newShortDescription);
        }
    }
}

@Override
public ErrorAggregateValue aggregate(Iterable<ErrorAggregateValue> aggValues) {
    ErrorAggregateValue errorSum = new ErrorAggregateValue();
    Iterator<ErrorAggregateValue> it = aggValues.iterator();
    double errorValue = 0.0;
    while (it.hasNext()) {
        errorValue += Double.parseDouble(it.next().getValue());
    }
    errorSum.setValue(Double.toString(errorValue));
    return errorSum;
}

public java.util.Iterator<?> iterator() {
    return new java.util.Iterator<org.eclipse.emf.ecore.EObject>() {

        private boolean hasNext = true;

        public boolean hasNext() {
            return hasNext;
        }

        public org.eclipse.emf.ecore.EObject next() {
            hasNext = false;
            return selectedObject;
        }

        public void remove() {
        }
    };
}

public java.util.Iterator<?> iterator() {
    return new java.util.Iterator<org.eclipse.emf.ecore.EObject>() {

        private boolean hasNext = true;

        public boolean hasNext() {
            return hasNext;
        }

        public org.eclipse.emf.ecore.EObject next() {
            hasNext = false;
            return selectedObject;
        }

        public void remove() {
        }
    };
}

public java.util.Iterator<?> iterator() {
    return new java.util.Iterator<org.eclipse.emf.ecore.EObject>() {

        private boolean hasNext = true;

        public boolean hasNext() {
            return hasNext;
        }

        public org.eclipse.emf.ecore.EObject next() {
            hasNext = false;
            return selectedObject;
        }

        public void remove() {
        }
    };
}

public java.util.Iterator<?> iterator() {
    return new java.util.Iterator<org.eclipse.emf.ecore.EObject>() {

        private boolean hasNext = true;

        public boolean hasNext() {
            return hasNext;
        }

        public org.eclipse.emf.ecore.EObject next() {
            hasNext = false;
            return selectedObject;
        }

        public void remove() {
        }
    };
}

public static double total(Document doc) {
    // Aggregate salaries
    double total = 0;
    // Iterate over all salary elements
    Iterator<?> iterator = doc.getDescendants(new ElementFilter("salary"));
    while (iterator.hasNext()) {
        Element elem = (Element) iterator.next();
        Double salary = Double.valueOf(elem.getText());
        total += salary;
    }
    return total;
}

public byte[] findClass(String name) {
    byte[] result = null;
    for (Iterator iter = classFinders.iterator(); iter.hasNext(); ) {
        IClassFinder classFinder = (IClassFinder) iter.next();
        result = classFinder.findClass(name);
        if (result != null) {
            break;
        }
    }
    return result;
}

public static String getAccessToken(TreeMap<String, String> map, String app_secret) {
    String toMd5 = "";
    Set<String> keys = map.keySet();
    Iterator<String> iterator = keys.iterator();
    while (iterator.hasNext()) {
        String key = iterator.next();
        toMd5 += key + "=" + map.get(key) + "&";
    }
    toMd5 = toMd5.substring(0, toMd5.length() - 1);
    toMd5 += app_secret;
    return MD5.digest(toMd5);
}

public static <S> S loadFirst(Class<S> clazz) {
    Iterator<S> iterator = loadAll(clazz);
    if (!iterator.hasNext()) {
        throw new IllegalStateException(String.format("No implementation defined in /META-INF/services/%s, please check whether the file exists and has the right implementation class!", clazz.getName()));
    }
    return iterator.next();
}

public static Map<String, String> decodeByDecodeNames(List<String> decodeNames, Map<String, String> map) {
    Set<String> keys = map.keySet();
    Iterator<String> it = keys.iterator();
    while (it.hasNext()) {
        String key = it.next();
        String value = map.get(key);
        for (String decodeName : decodeNames) {
            if (key.equals(decodeName)) {
                value = URLDecoder.decode(value);
                map.put(key, value);
            }
        }
    }
    return map;
}

public String toJson() {
    StringBuilder buf = new StringBuilder("[");
    Iterator<FullCalendarEventBean> iterator = list.iterator();
    while (iterator.hasNext()) {
        buf.append(iterator.next().toJson());
        if (iterator.hasNext()) {
            buf.append(",");
        }
    }
    buf.append("]");
    return buf.toString();
}

@Test
public void orderedMapsAreOrderedByInsertionSequence() {
    Map<String, String> map = Maps.createOrdered();
    map.put("B", "A");
    map.put("A", "B");
    Iterator<String> iterator = map.keySet().iterator();
    assertThat(iterator.next(), is("B"));
    assertThat(iterator.next(), is("A"));
    Iterator<String> iterator1 = map.values().iterator();
    assertThat(iterator1.next(), is("A"));
    assertThat(iterator1.next(), is("B"));
}

@Test
public void testObjectProperties() throws Exception {
    ObjectPropertyAssertion.of(ByteBuddyAgent.ProcessProvider.ForCurrentVm.ForLegacyVm.class).apply();
    final Iterator<Method> methods = Arrays.asList(Object.class.getDeclaredMethods()).iterator();
    ObjectPropertyAssertion.of(ByteBuddyAgent.ProcessProvider.ForCurrentVm.ForJava9CapableVm.class).create(new ObjectPropertyAssertion.Creator<Method>() {

        @Override
        public Method create() {
            return methods.next();
        }
    }).apply();
    ObjectPropertyAssertion.of(ByteBuddyAgent.AttachmentProvider.Accessor.Unavailable.class).apply();
}

@Override
public Iterator<View> iterator() {
    return new Iterator<View>() {

        int i = 0;

        @Override
        public boolean hasNext() {
            return i < layoutManager.getChildCount();
        }

        @Override
        public View next() {
            return layoutManager.getChildAt(i++);
        }
    };
}

@SubscribeEvent
public void onTick(TickEvent.ServerTickEvent event) {
    if (NukeRegistry.isExploding()) {
        Iterator<Explosion> i = NukeRegistry.getExplosions().iterator();
        while (i.hasNext()) {
            Explosion explosion = i.next();
            if (explosion.hasExploded()) {
                System.out.println("Ending Nuking");
                i.remove();
                return;
            }
            explosion.progress();
        }
    }
}

public static float computeAER(Iterator<ReferenceAlignment> refi, Iterator<Alignment> testi) {
    float num = 0.0f;
    float den = 0.0f;
    while (refi.hasNext()) {
        ReferenceAlignment ref = refi.next();
        Alignment test = testi.next();
        num += (ref.countProbableHits(test) + ref.countSureHits(test));
        den += (test.countAlignmentPoints() + ref.countAlignmentPoints());
    }
    if (testi.hasNext())
        throw new RuntimeException("Mismatch in lengths");
    return num / den;
}

/**
     * Visit the specified node.
     */
public Object visit(RelationNode node) {
    double num = 0;
    Object data = node.getData();
    if (data instanceof Number) {
        num += ((Number) data).doubleValue();
    }
    for (Iterator i = node.getChildren().iterator(); i.hasNext(); ) {
        Object tmp = ((RelationNode) i.next()).accept(this);
        if (tmp instanceof Number) {
            num += ((Number) tmp).doubleValue();
        }
    }
    return new Double(num);
}

public Iterator<E> iterator() {
    return new Iterator<E>() {

        private Iterator<E> it = iterable.iterator();

        public boolean hasNext() {
            if (!it.hasNext())
                it = iterable.iterator();
            return it.hasNext();
        }

        public E next() {
            if (!it.hasNext())
                it = iterable.iterator();
            return it.next();
        }

        public void remove() {
            it.remove();
        }
    };
}

public ComponentDescription mergeComponentDescriptions() {
    ComponentDescription result = new ComponentDescription();
    Iterator<ComponentDescription> itr = this.iterator();
    while (itr.hasNext()) {
        ComponentDescription cd = itr.next();
        for (Attribute att : cd.getConstantAttributesFull().values()) {
            result.getConstantAttributesFull().add(att);
        }
        for (Attribute att : cd.getNonConstantAttributes().values()) {
            result.getNonConstantAttributes().add(att);
        }
    // TODO unir os demais atributos. Poderam ser usados em algum momento. 
    }
    return result;
}

public void testPerformanceGetBeer() {
    Collection beers = beerService.findAll();
    java.util.Iterator itor = beers.iterator();
    String name = null;
    Beer beer = null;
    while (itor.hasNext()) {
        beer = (Beer) itor.next();
        name = beer.getName();
        System.out.println("name1=" + name);
    }
    if (beers != null && beers.size() > 0) {
        assertTrue(true);
    } else {
        assertTrue(false);
    }
}

public void testIterator() {
    Collection<String> c1 = Collections.singleton("a");
    Collection<String> c2 = Collections.singleton("b");
    Iterator<String> i = new ConcatenationIterator<String>(c1.iterator(), c2.iterator());
    assertEquals("a", i.next());
    assertEquals("b", i.next());
    assertFalse(i.hasNext());
}

@Test
public void should_load_test_resource_iterator() throws MalformedURLException {
    ResourceIteratorFactory factory = new DelegatingResourceIteratorFactory(new ZipThenFileResourceIteratorFactory());
    URL url = new URL(TestResourceIteratorFactory.TEST_URL);
    assertTrue(factory.isFactoryFor(url));
    Iterator<Resource> iterator = factory.createIterator(url, "test", "test");
    assertTrue(iterator instanceof TestResourceIterator);
}

@Override
public String getMessage() {
    StringBuilder builder = new StringBuilder("[");
    for (Iterator<ConstraintViolation<Object>> iterator = violations.iterator(); iterator.hasNext(); ) {
        builder.append(iterator.next().getMessage());
        if (iterator.hasNext()) {
            builder.append(", ");
        }
    }
    builder.append("]");
    return builder.toString();
}

public static String packagesToKey(Set<String> packages) {
    Set<String> sorted = new TreeSet<String>();
    sorted.addAll(packages);
    StringBuffer buffer = new StringBuffer();
    for (Iterator<String> iterator = sorted.iterator(); iterator.hasNext(); ) {
        String object = iterator.next();
        buffer.append("_").append(object);
    }
    return buffer.toString().replaceAll(":", "_");
}

@Override
public void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
    Iterator<Text> it = values.iterator();
    StringBuilder b = new StringBuilder();
    while (it.hasNext()) {
        //			b.append("---");
        b.append(" ");
        b.append(it.next());
    }
    //		b.append("---");
    b.append(" ");
    context.write(key, new Text(b.toString()));
}

public static List<String> getAliasesFromJson(String indexName, String jsonString) {
    List<String> retValue = new ArrayList<>();
    try {
        JSONObject json = new JSONObject(jsonString);
        JSONObject index = json.getJSONObject(indexName);
        JSONObject aliases = index.getJSONObject("aliases");
        for (Iterator iterator = aliases.keys(); iterator.hasNext(); ) {
            String key = (String) iterator.next();
            retValue.add(key);
        }
    } catch (JSONException e) {
        e.printStackTrace();
    }
    return retValue;
}

/**
   * @see org.eclipse.emf.diffmerge.util.structures.comparable.IComparableStructure#getCompareIterator()
   */
public Iterator<IComparableMapEntry<K, V>> getCompareIterator() {
    final Iterator<Map.Entry<K, V>> ascendingEntryIterator = // In ascending order
    entrySet().iterator();
    return new Iterator<IComparableMapEntry<K, V>>() {

        /**
       * @see java.util.Iterator#hasNext()
       */
        public boolean hasNext() {
            return ascendingEntryIterator.hasNext();
        }

        /**
       * @see java.util.Iterator#next()
       */
        public IComparableMapEntry<K, V> next() {
            Map.Entry<K, V> next = ascendingEntryIterator.next();
            return new ComparableMapEntry<K, V>(next);
        }

        /**
       * @see java.util.Iterator#remove()
       */
        public void remove() {
            throw new UnsupportedOperationException();
        }
    };
}

public void testIsLegalPath() {
    FileUtils util = new FileUtils();
    ArrayList ar = new ArrayList();
    ar.add("previous_photos/previous_photos/Photos/Institutional Advancement/DONORS/SBC/FRANK WEATHERS 10-03 COON /Weathers 01.JPG.xconf");
    ar.add("ABC\\DEFGHIJ\\KL?MNOP.xconf");
    ar.add("ABC\\DEFGHIJ\nKL\\MNOP.xconf");
    for (Iterator iterator = ar.iterator(); iterator.hasNext(); ) {
        String path = (String) iterator.next();
        assertFalse(util.isLegalFilename(path));
    }
}

public String toString() {
    Iterator it = values.iterator();
    StringBuilder builder = new StringBuilder();
    while (it.hasNext()) {
        Object object = (Object) it.next();
        builder.append(object);
        if (it.hasNext()) {
            builder.append(",");
        }
    }
    return builder.toString();
}

/**
     * 数组去除��元素
     */
public static List<String> removeDuplicateWithOrder(List<String> list) {
    Set<String> set = new HashSet<String>();
    List<String> newList = new ArrayList<String>();
    for (Iterator<String> iter = list.iterator(); iter.hasNext(); ) {
        String element = iter.next();
        if (set.add(element))
            newList.add(element);
    }
    list.clear();
    return newList;
}

public String get(String inId) {
    String val = getElement().attributeValue(inId);
    if (val == null) {
        for (Iterator iterator = getElement().elementIterator(); iterator.hasNext(); ) {
            Element ele = (Element) iterator.next();
            if (inId.equals(ele.attributeValue("id"))) {
                val = ele.getTextTrim();
                break;
            }
        }
    }
    return val;
}

@Override
public Iterator<T> iterator() {
    final ListIterator<T> iterator = list.listIterator(list.size());
    return new Iterator<T>() {

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

        @Override
        public T next() {
            return iterator.previous();
        }

        @Override
        public void remove() {
            iterator.remove();
        }
    };
}

public void serialize(PrintWriter out) {
    out.print("@import url(");
    out.print(url);
    out.print(")");
    if (mediaList != null) {
        Iterator it = mediaList.iterator();
        String sep = " ";
        while (it.hasNext()) {
            out.print(sep);
            out.print(it.next());
            sep = ", ";
        }
    }
    out.println(";");
}

public Object driver(String[] args) throws Throwable {
    setVersion("v2002.08.27");
    Collector collector = (Collector) original(args);
    List misDefined = collector.baliRules.misDefined();
    Collections.sort(misDefined);
    for (Iterator p = misDefined.iterator(); p.hasNext(); ) {
        String rule = (String) p.next();
        System.err.println("rule \"" + rule + "\" is referenced but not defined");
    }
    return collector;
}

@Override
public Iterator<Versioned<byte[]>> iterator() {
    final Iterator<VersionedValue> vs = tvvi.iterator();
    return new Iterator<Versioned<byte[]>>() {

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

        @Override
        public Versioned<byte[]> next() {
            return TProtocolUtil.getVersionedValued(vs.next());
        }

        @Override
        public void remove() {
            vs.remove();
        }
    };
}

@Override
public Iterator<Versioned<byte[]>> iterator() {
    final Iterator<VersionedValue> vs = tvvi.iterator();
    return new Iterator<Versioned<byte[]>>() {

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

        @Override
        public Versioned<byte[]> next() {
            return TProtocolUtil.getVersionedValued(vs.next());
        }

        @Override
        public void remove() {
            vs.remove();
        }
    };
}

@Override
public Iterator<Versioned<byte[]>> iterator() {
    final Iterator<VersionedValue> vs = tvvi.iterator();
    return new Iterator<Versioned<byte[]>>() {

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

        @Override
        public Versioned<byte[]> next() {
            return TProtocolUtil.getVersionedValued(vs.next());
        }

        @Override
        public void remove() {
            vs.remove();
        }
    };
}

@NonNull
@Override
public History scrubHistory(@NonNull History history) {
    History.Builder builder = History.emptyBuilder();
    final Iterator<Object> keys = history.reverseIterator();
    while (keys.hasNext()) {
        Object key = keys.next();
        if (!key.getClass().isAnnotationPresent(NotPersistent.class)) {
            builder.push(key);
        }
    }
    return builder.build();
}

/**
     * testFilter
     */
@Test
public void testFilter() throws Exception {
    int new_limit = 100;
    ProcedureLimitFilter filter = new ProcedureLimitFilter(new_limit);
    Iterator<TransactionTrace> it = workload.iterator(filter);
    assertNotNull(it);
    int count = 0;
    while (it.hasNext()) {
        AbstractTraceElement<? extends CatalogType> element = it.next();
        if (element instanceof TransactionTrace) {
            count++;
        }
    }
    // WHILE
    assertEquals(new_limit, count);
}

public Iterator<T> iterator() {
    return new Iterator<T>() {

        int idx = 0;

        public boolean hasNext() {
            return idx < obj.length();
        }

        public T next() {
            return obj.get(idx++);
        }

        public void remove() {
            assert false : "remove forbidden";
        }
    };
}

public static String join(String separator, String... strings) {
    StringBuilder sb = new StringBuilder();
    List<String> list = Lists.newList(strings);
    Iterator<String> itr = list.iterator();
    while (itr.hasNext()) {
        sb.append(itr.next());
        if (itr.hasNext())
            sb.append(separator);
    }
    return sb.toString();
}

@Test
public void testObjectProperties() throws Exception {
    ObjectPropertyAssertion.of(ByteBuddyAgent.ProcessProvider.ForCurrentVm.ForLegacyVm.class).apply();
    final Iterator<Method> methods = Arrays.asList(Object.class.getDeclaredMethods()).iterator();
    ObjectPropertyAssertion.of(ByteBuddyAgent.ProcessProvider.ForCurrentVm.ForJava9CapableVm.class).create(new ObjectPropertyAssertion.Creator<Method>() {

        @Override
        public Method create() {
            return methods.next();
        }
    }).apply();
    ObjectPropertyAssertion.of(ByteBuddyAgent.AttachmentProvider.Accessor.Unavailable.class).apply();
}

public static Object[] evaluateToArray(Object collection) {
    if (collection == null)
        return new Object[0];
    if (collection.getClass().isArray())
        return (Object[]) collection;
    if (collection instanceof Collection)
        return ((Collection) collection).toArray();
    if (collection instanceof Iterator) {
        List<Object> content_list = new ArrayList<Object>();
        for (Object o : content_list) {
            content_list.add(o);
        }
        return content_list.toArray();
    } else {
        return new Object[0];
    }
}

public void testList1() {
    int len = 5;
    LruList<String> l = new LruList<>(len);
    for (int i = 0; i < 8; i++) {
        l.add(String.valueOf(i + "val"));
    }
    assertEquals("[3val, 4val, 5val, 6val, 7val]", l.toString());
    assertEquals(len, l.size());
    Iterator<String> iterator = l.iterator();
    String testResult = "";
    while (iterator.hasNext()) {
        testResult += iterator.next();
    }
    assertEquals("3val4val5val6val7val", testResult);
    l.clear();
    assertEquals(0, l.size());
}

@SuppressWarnings("rawtypes")
public String getXmlBody() {
    StringBuilder sb = new StringBuilder();
    Set es = super.getAllParameters().entrySet();
    Iterator it = es.iterator();
    while (it.hasNext()) {
        Map.Entry entry = (Map.Entry) it.next();
        String k = (String) entry.getKey();
        String v = (String) entry.getValue();
        if (!"appkey".equals(k)) {
            sb.append("<" + k + ">" + v + "<" + k + ">" + "\r\n");
        }
    }
    return sb.toString();
}

@Test
public void getVerbsTest() throws IOException {
    VerbValencyReader vv = new VerbValencyReader();
    String expected = "بر";
    Iterator<Verb> iter = vv.getVerbs().iterator();
    iter.next();
    iter.next();
    iter.next();
    String actual = iter.next().Prefix;
    assertEquals("Failed to read verb valency corpus.", expected, actual);
}

@Override
public Result<WrappedCollection> convert(Object object) {
    if (object instanceof Iterable) {
        WrappedCollection result = new WrappedCollection();
        Iterator iterator = ((Iterable) object).iterator();
        int i = 0;
        while (iterator.hasNext()) {
            Object next = iterator.next();
            result.add(String.valueOf(i++), next);
        }
        return Result.defined(result);
    }
    return Result.undefined();
}

@SuppressWarnings("rawtypes")
public static String join(Collection items, String separator) {
    items = items == null ? Collections.emptySet() : items;
    separator = separator == null ? "" : separator;
    StringBuilder sb = new StringBuilder();
    int count = 1;
    Iterator it = items.iterator();
    while (it.hasNext()) {
        sb.append(it.next());
        if (count < items.size()) {
            sb.append(separator);
        }
        count++;
    }
    return sb.toString();
}

public synchronized void notifyNewState(int newState) {
    Iterator<MessengerStateListener> listenerIter = stateChangeListeners.iterator();
    while (listenerIter.hasNext()) {
        MessengerStateListener listener = listenerIter.next();
        if (!listener.messengerStateChanged(newState)) {
            listenerIter.remove();
        }
    }
}

public synchronized void notifyNewState(int newState) {
    Iterator<MessengerStateListener> listenerIter = stateChangeListeners.iterator();
    while (listenerIter.hasNext()) {
        MessengerStateListener listener = listenerIter.next();
        if (!listener.messengerStateChanged(newState)) {
            listenerIter.remove();
        }
    }
}

public static String join(String delimiter, Iterable<String> stringsIterable) {
    List<String> strings = new LinkedList<>();
    Iterator<String> iterator = stringsIterable.iterator();
    while (iterator.hasNext()) {
        strings.add(iterator.next());
    }
    StringBuilder ab = new StringBuilder();
    for (int i = 0; i < strings.size(); i++) {
        ab.append(strings.get(i));
        if (i != strings.size() - 1) {
            ab.append(delimiter);
        }
    }
    return ab.toString();
}

public static PropertyValue[] toPropertyValues(Map properties) {
    final PropertyValue[] ret = new PropertyValue[properties.size()];
    int i = 0;
    for (Iterator it = properties.entrySet().iterator(); it.hasNext(); ) {
        Map.Entry entry = (Map.Entry) it.next();
        String key = entry.getKey().toString();
        Object val = entry.getValue();
        ret[i] = new PropertyValue();
        ret[i].Name = key;
        ret[i].Value = (val instanceof Map) ? Utils.toPropertyValues((Map) val) : val;
        i++;
    }
    return ret;
}

@Override
public Iterator<Versioned<byte[]>> iterator() {
    final Iterator<VersionedValue> vs = tvvi.iterator();
    return new Iterator<Versioned<byte[]>>() {

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

        @Override
        public Versioned<byte[]> next() {
            return TProtocolUtil.getVersionedValued(vs.next());
        }

        @Override
        public void remove() {
            vs.remove();
        }
    };
}

public static void write(String parDirectory, String parFileName, Language parLanguage) {
    StringBuilder str = new StringBuilder();
    Iterator<String> iter = parLanguage.iterator();
    while (iter.hasNext()) {
        String unlocalized = iter.next();
        str.append(unlocalized + "=" + parLanguage.get(unlocalized) + "\n");
    }
    ResourceWriter.write(parDirectory, parFileName, str.toString());
}

public void tick() {
    for (Task task : taskQueue) {
        tasks.add(task);
    }
    taskQueue.clear();
    for (Iterator<Task> it = tasks.iterator(); it.hasNext(); ) {
        Task task = it.next();
        if (!task.isRunning()) {
            it.remove();
            continue;
        }
        task.tick();
    }
}

public static <T> void assertSameSequence(Iterable<T> expexted, Iterable<T> actual) {
    Iterator<T> expIt = Sequence.fromIterable(expexted).iterator();
    Iterator<T> testIt = Sequence.fromIterable(actual).iterator();
    while (expIt.hasNext() && testIt.hasNext()) {
        Assert.assertEquals(expIt.next(), testIt.next());
    }
    Assert.assertFalse(expIt.hasNext());
    Assert.assertFalse(testIt.hasNext());
}

@Test
public void testNoDuplicatesFilteringIterator() {
    List<Integer> ints = Arrays.asList(1, 2, 2, 40, 100, 40, 101, 2, 3);
    Iterator<Integer> iterator = FilteringIterator.noDuplicates(ints.iterator());
    assertEquals((Integer) 1, iterator.next());
    assertEquals((Integer) 2, iterator.next());
    assertEquals((Integer) 40, iterator.next());
    assertEquals((Integer) 100, iterator.next());
    assertEquals((Integer) 101, iterator.next());
    assertEquals((Integer) 3, iterator.next());
}

public void testSimple() {
    // arrange
    @SuppressWarnings("unchecked") Iterator<String> i = (Iterator<String>) mock(Iterator.class);
    when(i.next()).thenReturn("Hello").thenReturn("World");
    // act
    String result = i.next() + " " + i.next();
    // verify
    verify(i, times(2)).next();
    // assert
    assertEquals("Hello World", result);
}

@Override
public Object evaluate(Scope context) throws ExpressionException {
    boolean result = false;
    Iterator<?> argIt = arguments.iterator();
    while (argIt.hasNext()) {
        result = result || ((Boolean) ((Expression) argIt.next()).evaluate(context)).booleanValue();
        if (result)
            return Boolean.TRUE;
    }
    if (result)
        return Boolean.TRUE;
    return Boolean.FALSE;
}

public static <E> E randomElement(final Collection<E> c) {
    if (noItems(c)) {
        return null;
    }
    final int size = c.size();
    final int randomIndex = new Random().nextInt(size);
    final Iterator<E> it = c.iterator();
    int i = 0;
    while (it.hasNext()) {
        if (i == randomIndex) {
            return it.next();
        }
        i++;
    }
    return null;
}

@Test
public void testIteratorRemove() {
    final int paperSize = 400;
    CreasePattern cp = new CreasePattern(paperSize);
    cp.add(new OriLine(0.0, 0.0, 100.0, 100.0, OriLine.TYPE_RIDGE));
    cp.add(new OriLine(10.0, 10.0, 100.0, 100.0, OriLine.TYPE_RIDGE));
    cp.add(new OriLine(20.0, 20.0, 100.0, 100.0, OriLine.TYPE_RIDGE));
    for (Iterator<OriLine> iter = cp.iterator(); iter.hasNext(); ) {
        OriLine oriLine = iter.next();
        iter.remove();
    }
    assertTrue(cp.isEmpty());
}

public static String join(Collection<?> collection, String separator) {
    final Iterator<?> iterator = collection.iterator();
    final StringBuffer buffer = new StringBuffer();
    while (iterator.hasNext()) {
        final Object next = iterator.next();
        if (next != null) {
            buffer.append(next);
            if (iterator.hasNext())
                buffer.append(separator);
        }
    }
    return buffer.toString();
}

public static <E> AtomicIterator<E> atomicIteratorOf(final Iterator<E> backingIterator) {
    final Object monitor = new Object();
    return new AtomicIterator<E>() {

        @Override
        public Optional<E> next() {
            synchronized (monitor) {
                return backingIterator.hasNext() ? Optional.fromNullable(backingIterator.next()) : Optional.<E>absent();
            }
        }
    };
}

protected IBinder createBinder(EClass eClass) {
    List<EClass> superTypes = new ArrayList<EClass>(eClass.getEAllSuperTypes());
    superTypes.add(0, eClass);
    for (Iterator<EClass> it = superTypes.iterator(); it.hasNext(); ) {
        EClass superClass = it.next();
        IBinder binder = super.createBinder(superClass);
        if (binder != null) {
            return binder;
        }
    }
    return null;
}

public void testGetName() throws Exception {
    PlexusIoFileResourceCollection coll = new PlexusIoFileResourceCollection();
    char nonSeparator = File.separatorChar == '/' ? '\\' : '/';
    coll.setPrefix("fud" + nonSeparator);
    coll.setBaseDir(new File("src/test/resources/symlinks"));
    final Iterator<PlexusIoResource> resources = coll.getResources();
    while (resources.hasNext()) {
        final PlexusIoResource next = resources.next();
        final String name = coll.getName(next);
        assertTrue(name.indexOf(nonSeparator) < 0);
    }
}

public String formatLogs(List<LogEntry> logs, LogFormatter formatter, FormatManager pollyFormat) {
    StringWriter string = new StringWriter();
    PrintWriter pw = new PrintWriter(string);
    Iterator<LogEntry> it = logs.iterator();
    while (it.hasNext()) {
        LogEntry log = it.next();
        pw.print(formatter.formatLog(log, pollyFormat));
        if (it.hasNext()) {
            pw.println();
        }
    }
    return string.toString();
}

/**
     * Initialize this iterator for the given source iterator and
     * comparator.
     * @param iter the source iterator of tuples
     * @param c the comparator to use for sorting
     */
public void init(Iterator iter, Comparator c) {
    m_tuples.clear();
    m_cmp = c;
    // populate tuple list
    while (iter.hasNext()) {
        Tuple t = (Tuple) iter.next();
        m_tuples.add(t);
    }
    // sort tuple list
    Collections.sort(m_tuples, m_cmp);
    // create sorted iterator
    m_iter = m_tuples.iterator();
}

@Override
public boolean processCommand(ICommandSender sender, String[] parameters) {
    try {
        StringBuilder builder = new StringBuilder();
        Iterator<Potion> it = Potion.REGISTRY.iterator();
        while (it.hasNext()) {
            builder.append(it.next().getRegistryName() + "\n");
        }
        PrintWriter writer = new PrintWriter("potions.log", "UTF-8");
        writer.write(builder.toString());
        writer.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return true;
}

@Override
public void run() {
    for (Iterator<Rocket> it = Gizmos.rocketGizmo.rockets.iterator(); it.hasNext(); ) {
        Rocket rocket = it.next();
        if (rocket.allFireworksAlive()) {
            Vector center = rocket.getCenter();
            Vector delta = center.clone().subtract(rocket.getPreviousCenter());
            RocketUtils.fakeDelta(rocket.getObserver(), rocket.getVictim(), delta);
            rocket.setPreviousCenter(center);
        } else {
            rocket.getObserver().hidePlayer(rocket.getVictim());
            it.remove();
        }
    }
}

public Iterator<T> iterator() {
    return new Iterator<T>() {

        private int index = 0;

        public boolean hasNext() {
            return index < repititions;
        }

        public T next() {
            if (index >= repititions)
                throw new ArrayIndexOutOfBoundsException();
            index++;
            return value;
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    };
}

@Override
public void initEnd(FMLInitializationEvent event, boolean client) {
    thaumcraftRecipeList = new RecipeListGetter() {

        @Override
        public Iterator<?> getIterator() {
            return ThaumcraftApi.getCraftingRecipes().listIterator();
        }
    };
    RecipeHelper.registerRecipeListGetter(thaumcraftRecipeList);
    RecipeHelper.addRecipeComponentTranslator(thaumcraftRecipeList, ShapedArcaneRecipe.class, new ShapedArcaneRecipeCT());
}

public static void initIDESupport() {
    ServiceLoader<IIDESupport> sloader = ServiceLoader.load(IIDESupport.class);
    Iterator<IIDESupport> supIterator = sloader.iterator();
    while (supIterator.hasNext()) {
        IIDESupport current = supIterator.next();
        try {
            for (String ending : current.getEndings()) {
                ideSupporter.put(ending, current);
            }
        } catch (Exception ex) {
        }
    }
}