public void TestListIterator()
{
Object tempValue;
List <Object> list = new ArrayList <Object>();
list.Add(3);
list.Add(5);
list.Add(5);
list.Add(1);
list.Add(7);
ListIterator <Object> lit = list.ListIterator();
Assert.IsTrue(!lit.HasPrevious, "Should not have previous");
Assert.IsTrue(lit.HasNext, "Should have next");
tempValue = lit.Next();
Assert.IsTrue(tempValue.Equals(3),
"next returned wrong value. Wanted 3, got: " + tempValue);
tempValue = lit.Previous();
SimpleList <Object> list2 = new SimpleList <Object>();
list2.Add(new Object());
ListIterator <Object> lit2 = list2.ListIterator();
lit2.Add(new Object());
lit2.Next();
list = new MockArrayList <Object>();
ListIterator <Object> it = list.ListIterator();
it.Add("one");
it.Add("two");
Assert.AreEqual(2, list.Size());
}
/// <summary>Merges items from buffer into the samples array in one pass.</summary>
/// <remarks>
/// Merges items from buffer into the samples array in one pass.
/// This is more efficient than doing an insert on every item.
/// </remarks>
private void InsertBatch()
{
if (bufferCount == 0)
{
return;
}
Arrays.Sort(buffer, 0, bufferCount);
// Base case: no samples
int start = 0;
if (samples.Count == 0)
{
SampleQuantiles.SampleItem newItem = new SampleQuantiles.SampleItem(buffer[0], 1,
0);
samples.AddItem(newItem);
start++;
}
ListIterator <SampleQuantiles.SampleItem> it = samples.ListIterator();
SampleQuantiles.SampleItem item = it.Next();
for (int i = start; i < bufferCount; i++)
{
long v = buffer[i];
while (it.NextIndex() < samples.Count && item.value < v)
{
item = it.Next();
}
// If we found that bigger item, back up so we insert ourselves before it
if (item.value > v)
{
it.Previous();
}
// We use different indexes for the edge comparisons, because of the above
// if statement that adjusts the iterator
int delta;
if (it.PreviousIndex() == 0 || it.NextIndex() == samples.Count)
{
delta = 0;
}
else
{
delta = ((int)Math.Floor(AllowableError(it.NextIndex()))) - 1;
}
SampleQuantiles.SampleItem newItem = new SampleQuantiles.SampleItem(v, 1, delta);
it.Add(newItem);
item = newItem;
}
bufferCount = 0;
}
public void AddInIteratorTest()
{
ExtendedOneWayLinkedListWithHead <int> lista = new ExtendedOneWayLinkedListWithHead <int>();
lista.Add(1);
lista.Add(2);
lista.Add(3);
ListIterator <int> iterator = lista.GetListIterator();
List <int> actual = new List <int>();
while (iterator.HasNext())
{
actual.Add(iterator.Next());
iterator.Add(8);
actual.Add(iterator.Previous());
actual.Add(iterator.Next());
}
List <int> lista2 = new List <int> {
1, 8, 8, 2, 8, 8, 3, 8, 8
};
Assert.AreEqual(lista2.Count, actual.Count);
IEnumerator <int> iterator1 = actual.GetEnumerator();
IEnumerator <int> iterator2 = lista2.GetEnumerator();
while (iterator1.MoveNext() && iterator2.MoveNext())
{
Assert.AreEqual(iterator1.Current, iterator2.Current);
}
lista2 = new List <int> {
1, 8, 2, 8, 3, 8
};
Assert.AreEqual(lista2.Count, lista.Count);
iterator1 = lista.GetEnumerator();
iterator2 = lista2.GetEnumerator();
while (iterator1.MoveNext() && iterator2.MoveNext())
{
Assert.AreEqual(iterator1.Current, iterator2.Current);
}
}
// Bulk Operations
/// <summary>
/// Inserts all of the elements in the specified collection into this
/// list at the specified position (optional operation). Shifts the
/// element currently at that position (if any) and any subsequent
/// elements to the right (increases their indices). The new elements
/// will appear in this list in the order that they are returned by the
/// specified collection's iterator. The behavior of this operation is
/// undefined if the specified collection is modified while the
/// operation is in progress. (Note that this will occur if the specified
/// collection is this list, and it's nonempty.)
///
/// <para>This implementation gets an iterator over the specified collection and
/// a list iterator over this list pointing to the indexed element (with
/// <tt>listIterator(index)</tt>). Then, it iterates over the specified
/// collection, inserting the elements obtained from the iterator into this
/// list, one at a time, using <tt>ListIterator.add</tt> followed by
/// <tt>ListIterator.next</tt> (to skip over the added element).
///
/// </para>
/// <para>Note that this implementation will throw an
/// <tt>UnsupportedOperationException</tt> if the list iterator returned by
/// the <tt>listIterator</tt> method does not implement the <tt>add</tt>
/// operation.
///
/// </para>
/// </summary>
/// <exception cref="UnsupportedOperationException"> {@inheritDoc} </exception>
/// <exception cref="ClassCastException"> {@inheritDoc} </exception>
/// <exception cref="NullPointerException"> {@inheritDoc} </exception>
/// <exception cref="IllegalArgumentException"> {@inheritDoc} </exception>
/// <exception cref="IndexOutOfBoundsException"> {@inheritDoc} </exception>
public virtual bool addAll <T1>(int index, Collection <T1> c) where T1 : E
{
try
{
bool modified = false;
ListIterator <E> e1 = ListIterator(index);
//JAVA TO C# CONVERTER TODO TASK: Java wildcard generics are not converted to .NET:
//ORIGINAL LINE: Iterator<? extends E> e2 = c.iterator();
Iterator <?> e2 = c.Iterator();
while (e2.HasNext())
{
e1.Add(e2.Next());
modified = true;
}
return(modified);
}
catch (NoSuchElementException)
{
throw new IndexOutOfBoundsException("Index: " + index);
}
}
public void Add(E element)
{
iterator.Add(element);
subList.SizeChanged(true);
end++;
}
