Patch fixes issue 3057 and adds test cases for it.
Patch by: amitmanjhi
Review by: scottb
git-svn-id: https://google-web-toolkit.googlecode.com/svn/trunk@5366 8db76d5a-ed1c-0410-87a9-c151d255dfc7
diff --git a/user/super/com/google/gwt/emul/java/util/AbstractList.java b/user/super/com/google/gwt/emul/java/util/AbstractList.java
index d8e4a2e..7a08442 100644
--- a/user/super/com/google/gwt/emul/java/util/AbstractList.java
+++ b/user/super/com/google/gwt/emul/java/util/AbstractList.java
@@ -218,7 +218,7 @@
}
public ListIterator<E> listIterator() {
- return new ListIteratorImpl();
+ return listIterator(0);
}
public ListIterator<E> listIterator(int from) {
diff --git a/user/test/com/google/gwt/emultest/java/util/AbstractSequentialListTest.java b/user/test/com/google/gwt/emultest/java/util/AbstractSequentialListTest.java
new file mode 100644
index 0000000..e8d6369
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/util/AbstractSequentialListTest.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2009 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.emultest.java.util;
+
+import java.util.AbstractSequentialList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+
+/**
+ * Test custom iterators for AbstractSequentialList. Checks issue 3057.
+ */
+@SuppressWarnings("unchecked")
+public class AbstractSequentialListTest extends EmulTestBase {
+
+ // a simple wrapper over LinkedList.
+ private class AbstractSequentialListImpl<E> extends AbstractSequentialList<E> {
+
+ private LinkedList<E> internalList = new LinkedList<E>();
+
+ @Override
+ public ListIterator<E> listIterator(final int index) {
+ // a custom iterator that skips the 3rd element
+ return new ListIterator<E>() {
+
+ int position = index;
+
+ @Override
+ public void add(E e) {
+ internalList.add(position, e);
+ position++;
+ }
+
+ @Override
+ public boolean hasNext() {
+ return position < internalList.size();
+ }
+
+ @Override
+ public boolean hasPrevious() {
+ return position > 0;
+ }
+
+ @Override
+ public E next() {
+ E el = internalList.get(position);
+ position++;
+ // skip the 3rd element
+ if (position == 3) {
+ return next();
+ }
+ return el;
+ }
+
+ @Override
+ public int nextIndex() {
+ throw new UnsupportedOperationException(
+ "nextIndex operation not supported");
+ }
+
+ @Override
+ public E previous() {
+ throw new UnsupportedOperationException(
+ "previous operation not supported");
+ }
+
+ @Override
+ public int previousIndex() {
+ throw new UnsupportedOperationException(
+ "previousIndex operation not supported");
+ }
+
+ @Override
+ public void remove() {
+ throw new UnsupportedOperationException(
+ "remove operation not supported");
+ }
+
+ @Override
+ public void set(E e) {
+ throw new UnsupportedOperationException("set operation not supported");
+ }
+
+ };
+ }
+
+ @Override
+ public int size() {
+ return internalList.size();
+ }
+ }
+
+ public void testIteratorFunction() {
+ List l = new AbstractSequentialListImpl<Integer>();
+ int firstFivePrimes[] = {2, 3, 5, 7, 11};
+ for (int prime : firstFivePrimes) {
+ l.add(new Integer(prime));
+ }
+ assertEquals(5, l.size());
+
+ /*
+ * check that the iteration order is correct irrespective of whether
+ * iterator(), listIterator(), or listIterator(0) is called.
+ */
+ checkIterator(l.iterator());
+ checkIterator(l.listIterator());
+ checkIterator(l.listIterator(0));
+ }
+
+ private void checkIterator(Iterator iterator) {
+ assertEquals(new Integer(2), iterator.next());
+ assertEquals(new Integer(3), iterator.next());
+ // assertEquals(new Integer(5), iterator.next()); // skip 3rd element
+ assertEquals(new Integer(7), iterator.next());
+ assertEquals(new Integer(11), iterator.next());
+ }
+
+}
