package com.carrotsearch.hppc;
import static com.carrotsearch.hppc.TestUtils.*;
import static org.junit.Assert.*;
import java.util.*;
import org.junit.*;
import org.junit.rules.MethodRule;
import com.carrotsearch.hppc.cursors.FloatCursor;
import com.carrotsearch.hppc.mutables.IntHolder;
import com.carrotsearch.hppc.predicates.FloatPredicate;
import com.carrotsearch.hppc.procedures.FloatProcedure;
/**
* Unit tests for {@link FloatArrayDeque}.
*/
public class FloatArrayDequeTest
{
/**
* Per-test fresh initialized instance.
*/
public FloatArrayDeque deque;
/**
* Require assertions for all tests.
*/
@Rule
public MethodRule requireAssertions = new RequireAssertionsRule();
/**
* Some sequence values for tests.
*/
private FloatArrayList sequence = new FloatArrayList();
/* replaceIf:applied. */ float /* end */ key1 = 1;
/* replaceIf:applied. */ float /* end */ key2 = 2;
/* replaceIf:applied. */ float /* end */ key3 = 3;
/* */
@Before
public void initialize()
{
deque = new FloatArrayDeque();
sequence.clear();
for (int i = 0; i < 10000; i++)
sequence.add( (float) i);
}
@After
public void checkTrailingSpaceUninitialized()
{
if (deque != null)
{
for (int i = deque.tail; i < deque.head; i = FloatArrayDeque.oneRight(i, deque.buffer.length))
assertTrue(((float) 0) == deque.buffer[i]);
}
}
/* */
@Test
public void testInitiallyEmpty()
{
assertEquals(0, deque.size());
}
/* */
@Test
public void testAddFirst()
{
deque.addFirst( (float) 1);
deque.addFirst( (float) 2);
deque.addFirst( (float) 3);
assertListEquals(deque.toArray(), 3, 2, 1);
assertEquals(3, deque.size());
}
/* */
@Test
public void testAddLast()
{
deque.addLast( (float) 1);
deque.addLast( (float) 2);
deque.addLast( (float) 3);
assertListEquals(deque.toArray(), 1, 2, 3);
assertEquals(3, deque.size());
}
/* */
@Test
public void testAddWithGrowth()
{
for (int i = 0; i < sequence.size(); i++)
{
deque.addFirst(sequence.buffer[i]);
}
assertListEquals(reverse(sequence.toArray()), deque.toArray());
}
/* */
@Test
public void testAddLastWithGrowth()
{
for (int i = 0; i < sequence.size(); i++)
deque.addLast(sequence.buffer[i]);
assertListEquals(sequence.toArray(), deque.toArray());
}
/* */
@Test
public void testAddAllFirst()
{
FloatArrayList list2 = new FloatArrayList();
list2.add(newArray(list2.buffer, 0, 1, 2));
deque.addFirst(list2);
assertListEquals(deque.toArray(), 2, 1, 0);
deque.addFirst(list2);
assertListEquals(deque.toArray(), 2, 1, 0, 2, 1, 0);
deque.clear();
FloatArrayDeque deque2 = new FloatArrayDeque();
deque2.addLast(newArray(deque2.buffer, 0, 1, 2));
deque.addFirst(deque2);
assertListEquals(deque.toArray(), 2, 1, 0);
}
/* */
@Test
public void testAddAllLast()
{
FloatArrayList list2 = new FloatArrayList();
list2.add(newArray(list2.buffer, 0, 1, 2));
deque.addLast(list2);
assertListEquals(deque.toArray(), 0, 1, 2);
deque.addLast(list2);
assertListEquals(deque.toArray(), 0, 1, 2, 0, 1, 2);
deque.clear();
FloatArrayDeque deque2 = new FloatArrayDeque();
deque2.addLast(newArray(deque2.buffer, 0, 1, 2));
deque.addLast(deque2);
assertListEquals(deque.toArray(), 0, 1, 2);
}
/* */
@Test
public void testRemoveFirst()
{
deque.addLast( (float) 1);
deque.addLast( (float) 2);
deque.addLast( (float) 3);
deque.removeFirst();
assertListEquals(deque.toArray(), 2, 3);
assertEquals(2, deque.size());
deque.addFirst( (float) 4);
assertListEquals(deque.toArray(), 4, 2, 3);
assertEquals(3, deque.size());
deque.removeFirst();
deque.removeFirst();
deque.removeFirst();
assertEquals(0, deque.toArray().length);
assertEquals(0, deque.size());
}
/* */
@Test(expected = AssertionError.class)
public void testRemoveFirstEmpty()
{
deque.removeFirst();
}
/* */
@Test
public void testRemoveLast()
{
deque.addLast( (float) 1);
deque.addLast( (float) 2);
deque.addLast( (float) 3);
deque.removeLast();
assertListEquals(deque.toArray(), 1, 2);
assertEquals(2, deque.size());
deque.addLast( (float) 4);
assertListEquals(deque.toArray(), 1, 2, 4);
assertEquals(3, deque.size());
deque.removeLast();
deque.removeLast();
deque.removeLast();
assertEquals(0, deque.toArray().length);
assertEquals(0, deque.size());
}
/* */
@Test(expected = AssertionError.class)
public void testRemoveLastEmpty()
{
deque.removeLast();
}
/* */
@Test
public void testGetFirst()
{
deque.addLast( (float) 1);
deque.addLast( (float) 2);
assertEquals2( (float) 1, deque.getFirst());
deque.addFirst( (float) 3);
assertEquals2( (float) 3, deque.getFirst());
}
/* */
@Test(expected = AssertionError.class)
public void testGetFirstEmpty()
{
deque.getFirst();
}
/* */
@Test
public void testGetLast()
{
deque.addLast( (float) 1);
deque.addLast( (float) 2);
assertEquals2( (float) 2, deque.getLast());
deque.addLast( (float) 3);
assertEquals2( (float) 3, deque.getLast());
}
/* */
@Test(expected = AssertionError.class)
public void testGetLastEmpty()
{
deque.getLast();
}
/* */
@Test
public void testRemoveFirstOccurrence()
{
int modulo = 10;
int count = 10000;
sequence.clear();
for (int i = 0; i < count; i++)
{
deque.addLast( (float) (i % modulo));
sequence.add( (float) (i % modulo));
}
Random rnd = new Random(0x11223344);
for (int i = 0; i < 500; i++)
{
/* replaceIf:applied. */ float /* end */ k =
(float) rnd.nextInt(modulo);
assertEquals(
deque.removeFirstOccurrence(k) >= 0,
sequence.removeFirstOccurrence(k) >= 0);
}
assertListEquals(deque.toArray(), sequence.toArray());
assertTrue(0 > deque.removeFirstOccurrence( (float) (modulo + 1)));
deque.addLast( (float) (modulo + 1));
assertTrue(0 <= deque.removeFirstOccurrence( (float) (modulo + 1)));
}
/* */
@Test
public void testRemoveLastOccurrence()
{
int modulo = 10;
int count = 10000;
sequence.clear();
for (int i = 0; i < count; i++)
{
deque.addLast( (float) (i % modulo));
sequence.add( (float) (i % modulo));
}
Random rnd = new Random(0x11223344);
for (int i = 0; i < 500; i++)
{
/* replaceIf:applied. */ float /* end */ k =
(float) rnd.nextInt(modulo);
assertEquals(
deque.removeLastOccurrence(k) >= 0,
sequence.removeLastOccurrence(k) >= 0);
}
assertListEquals(deque.toArray(), sequence.toArray());
assertTrue(0 > deque.removeLastOccurrence( (float) (modulo + 1)));
deque.addFirst( (float) (modulo + 1));
assertTrue(0 <= deque.removeLastOccurrence( (float) (modulo + 1)));
}
/* */
@Test
public void testRemoveAllOccurrences()
{
deque.addLast(newArray(deque.buffer, 0, 1, 2, 1, 0, 3, 0));
assertEquals(0, deque.removeAllOccurrences( (float) 4));
assertEquals(3, deque.removeAllOccurrences( (float) 0));
assertListEquals(deque.toArray(), 1, 2, 1, 3);
assertEquals(1, deque.removeAllOccurrences( (float) 3));
assertListEquals(deque.toArray(), 1, 2, 1);
assertEquals(2, deque.removeAllOccurrences( (float) 1));
assertListEquals(deque.toArray(), 2);
assertEquals(1, deque.removeAllOccurrences( (float) 2));
assertEquals(0, deque.size());
}
/* */
@Test
public void testRemoveAllInLookupContainer()
{
deque.addLast(newArray(deque.buffer, 0, 1, 2, 1, 0));
FloatOpenHashSet set = new FloatOpenHashSet();
set.add(newArray(set.keys, 0, 2));
assertEquals(3, deque.removeAll(set));
assertEquals(0, deque.removeAll(set));
assertListEquals(deque.toArray(), 1, 1);
}
/* */
@Test
public void testRemoveAllWithPredicate()
{
deque.addLast(newArray(deque.buffer, 0, key1, key2, key1, 4));
assertEquals(3, deque.removeAll(new FloatPredicate()
{
public boolean apply(/* replaceIf:applied. */ float /* end */ v)
{
return v == key1 || v == key2;
};
}));
assertListEquals(deque.toArray(), 0, 4);
}
/* */
@Test
public void testRemoveAllWithPredicateInterrupted()
{
deque.addLast(newArray(deque.buffer, 0, key1, key2, key1, 4));
final RuntimeException t = new RuntimeException();
try
{
assertEquals(3, deque.removeAll(new FloatPredicate()
{
public boolean apply(/* replaceIf:applied. */ float /* end */ v)
{
if (v == key2) throw t;
return v == key1;
};
}));
fail();
}
catch (RuntimeException e)
{
// Make sure it's really our exception...
if (e != t) throw e;
}
// And check if the deque is in consistent state.
assertListEquals(deque.toArray(), 0, key2, key1, 4);
assertEquals(4, deque.size());
}
/* */
@Test
public void testClear()
{
deque.addLast( (float) 1);
deque.addLast( (float) 2);
deque.addFirst( (float) 3);
deque.clear();
assertEquals(0, deque.size());
assertEquals(0, deque.head);
assertEquals(0, deque.tail);
deque.addLast( (float) 1);
assertListEquals(deque.toArray(), 1);
}
/* */
@Test
public void testRelease()
{
deque.addLast( (float) 1);
deque.addLast( (float) 2);
deque.addFirst( (float) 3);
deque.release();
assertEquals(0, deque.size());
assertEquals(0, deque.head);
assertEquals(0, deque.tail);
deque.addLast( (float) 1);
assertListEquals(deque.toArray(), 1);
}
/* */
@Test
public void testIterable()
{
deque.addLast(sequence);
int count = 0;
for (FloatCursor cursor : deque)
{
assertEquals2(sequence.buffer[count], cursor.value);
assertEquals2(deque.buffer[cursor.index], cursor.value);
count++;
}
assertEquals(count, deque.size());
assertEquals(count, sequence.size());
count = 0;
deque.clear();
for (@SuppressWarnings("unused") FloatCursor cursor : deque)
{
count++;
}
assertEquals(0, count);
}
/* */
@Test
public void testIterator()
{
deque.addLast(newArray(deque.buffer, 0, 1, 2, 3));
Iterator<FloatCursor> iterator = deque.iterator();
int count = 0;
while (iterator.hasNext())
{
iterator.hasNext();
iterator.hasNext();
iterator.hasNext();
iterator.next();
count++;
}
assertEquals(count, deque.size());
deque.clear();
assertFalse(deque.iterator().hasNext());
}
/* */
@Test
public void testDescendingIterator()
{
deque.addLast(sequence);
int index = sequence.size() - 1;
for (Iterator<FloatCursor> i = deque.descendingIterator(); i.hasNext(); )
{
FloatCursor cursor = i.next();
assertEquals2(sequence.buffer[index], cursor.value);
assertEquals2(deque.buffer[cursor.index], cursor.value);
index--;
}
assertEquals(-1, index);
deque.clear();
assertFalse(deque.descendingIterator().hasNext());
}
/* */
@Test
/* removeIf:applied. */
public void testForEachWithProcedure()
{
deque.addLast(sequence);
final IntHolder count = new IntHolder();
((FloatArrayDeque) deque).forEach(new FloatProcedure() {
int index = 0;
public void apply(float v)
{
assertEquals2(sequence.buffer[index++], v);
count.value++;
}
});
assertEquals(count.value, deque.size());
}
/* */
@Test
/* removeIf:applied. */
public void testDescendingForEachWithProcedure()
{
deque.addLast(sequence);
final IntHolder count = new IntHolder();
((FloatArrayDeque) deque).descendingForEach(new FloatProcedure() {
int index = sequence.size();
public void apply(float v)
{
assertEquals2(sequence.buffer[--index], v);
count.value++;
}
});
assertEquals(count.value, deque.size());
}
/* removeIf:applied. */
/* */
@Test
public void testHashCodeEquals()
{
FloatArrayDeque l0 = FloatArrayDeque.from();
assertEquals(1, l0.hashCode());
assertEquals(l0, FloatArrayDeque.from());
FloatArrayDeque l1 = FloatArrayDeque.from(
(float) 1,
(float) 2,
(float) 3);
FloatArrayDeque l2 = FloatArrayDeque.from(
(float) 1,
(float) 2,
(float) 3);
assertEquals(l1.hashCode(), l2.hashCode());
assertEquals(l1, l2);
}
/* removeIf:applied. */
}