package org.squarebrackets;
import org.junit.Before;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.nio.ByteBuffer;
import java.nio.LongBuffer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
/**
* @author Leon van Zantvoort
*/
@SuppressWarnings({"MissingMethodJavaDoc", "MissingFieldJavaDoc"})
public class MutableLongBufferArrayTest {
private MutableLongArray array;
@Before
public void setUp() throws Exception {
long[] a = new long[] {0, 0, 1, 1, 2, 1, 2, 3, 3, 4};
LongBuffer buffer = LongBuffer.wrap(a, 1, 9);
array = MutableLongArray.valueOf(buffer);
array = serializeAndDeserialize(array); // Test serialization.
array = Arrays.synchronizedArray(array, array); // Test synchronized array.
array = array.offset(1);
}
@Test
public void nullable() {
assertTrue(array.hasCharacteristics(ArrayCharacteristics.NONNULL));
}
@Test
public void mutable() {
assertTrue(array.hasCharacteristics(ArrayCharacteristics.MUTABLE));
}
@Test
public void unbounded() {
assertFalse(array.hasCharacteristics(ArrayCharacteristics.REPLACEABLE));
}
@Test
public void copyFactory() throws Exception {
UnboundedLongArray d = UnboundedLongArray.copyOf(array);
d.setLong(0, 0);
assertArrayEquals(new long[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray());
assertArrayEquals(new long[]{0, 1, 2, 1, 2, 3, 3, 4}, d.toArray());
}
@Test
public void testSerialization() throws Exception {
Array<?> a = serializeAndDeserialize(array);
assertEquals(array, a);
}
@Test
public void testSetAll() throws Exception {
UnboundedLongArray smaller = UnboundedLongArray.copyOf(array);
smaller.longRemove();
try {
array.setAll(smaller);
fail();
} catch (IllegalStateException ignore) {
}
assertArrayEquals(new long[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray());
MutableLongArray backedByArray = MutableLongArray.copyOf(array);
Arrays.reverse(backedByArray);
array.setAll(backedByArray);
assertArrayEquals(new long[]{4, 3, 3, 2, 1, 2, 1, 1}, array.toArray());
LongBuffer buffer = ByteBuffer.allocateDirect(Long.SIZE / Byte.SIZE * 8).asLongBuffer();
MutableLongArray notBackedByArray = Arrays.newMutableArray(buffer);
notBackedByArray.setAll(backedByArray);
array.setAll(notBackedByArray);
assertArrayEquals(new long[]{4, 3, 3, 2, 1, 2, 1, 1}, array.toArray());
UnboundedLongArray tooBig = UnboundedLongArray.copyOf(array);
tooBig.addLong(0);
try {
array.setAll(tooBig);
fail();
} catch (IllegalStateException ignore) {
}
assertArrayEquals(new long[]{4, 3, 3, 2, 1, 2, 1, 1}, array.toArray());
}
@Test
public void testContains() throws Exception {
assertTrue(array.containsLong(1));
assertTrue(array.containsLong(4));
assertFalse(array.containsLong(5));
assertFalse(array.length(7).containsLong(4));
assertFalse(array.contains(null));
}
@Test
public void testContainsObject() throws Exception {
assertTrue(array.contains(1L));
assertTrue(array.contains(4L));
assertFalse(array.contains(5L));
assertFalse(array.length(7).contains(4L));
assertFalse(array.contains(null));
}
@Test
public void testContainsSorted() throws Exception {
array.sort();
assertTrue(array.containsLong(1));
assertTrue(array.containsLong(4));
assertFalse(array.containsLong(5));
assertFalse(array.length(7).containsLong(4));
assertFalse(array.contains(null));
}
@Test
public void testContainsAll() throws Exception {
MutableLongArray testTrue = MutableLongArray.valueOf(1, 2, 3);
MutableLongArray testFalse = MutableLongArray.valueOf(3, 4, 5);
assertTrue(array.containsAll(testTrue));
assertFalse(array.length(5).containsAll(testTrue));
assertFalse(array.containsAll(testFalse));
UnboundedObjectArray<Long> objectTestTrue = UnboundedObjectArray.valueOf(1L, 2L, 3L);
assertTrue(array.containsAll(objectTestTrue));
UnboundedObjectArray<Long> objectTestFalse = UnboundedObjectArray.valueOf(3L, 4L, 5L);
assertFalse(array.containsAll(objectTestFalse));
UnboundedObjectArray<Integer> objectTestOther = UnboundedObjectArray.valueOf(1, 2, 3);
assertFalse(array.containsAll(objectTestOther));
}
@Test
public void testContainsAllSorted() throws Exception {
array.sort();
MutableLongArray testTrue = MutableLongArray.valueOf(1, 2, 3);
testTrue.sort();
MutableLongArray testFalse = MutableLongArray.valueOf(3, 4, 5);
testFalse.sort();
assertTrue(array.containsAll(testTrue));
assertFalse(array.length(5).containsAll(testTrue));
assertFalse(array.containsAll(testFalse));
}
@Test
public void testIndexOf() throws Exception {
assertEquals(-1, array.indexOf(null));
assertEquals(0, array.indexOfLong(1));
assertEquals(7, array.indexOfLong(4));
}
@Test
public void testLastIndexOf() throws Exception {
assertEquals(-1, array.lastIndexOf(null));
assertEquals(3, array.lastIndexOfLong(1));
assertEquals(7, array.lastIndexOfLong(4));
}
@Test
public void testIndexOfSubArray() throws Exception {
assertEquals(-1, array.offset(1).indexOf(null));
assertEquals(0, array.offset(1).indexOfLong(1));
assertEquals(6, array.offset(1).indexOfLong(4));
}
@Test
public void testLastIndexOfSubArray() throws Exception {
assertEquals(-1, array.offset(1).lastIndexOf(null));
assertEquals(2, array.offset(1).lastIndexOfLong(1));
assertEquals(6, array.offset(1).lastIndexOfLong(4));
}
@Test
public void testIndexOfSorted() throws Exception {
array.sort();
assertEquals(-1, array.indexOf(null));
assertEquals(0, array.indexOfLong(1));
assertEquals(7, array.indexOfLong(4));
}
@Test
public void testLastIndexOfSorted() throws Exception {
array.sort();
assertEquals(-1, array.lastIndexOf(null));
assertEquals(2, array.lastIndexOfLong(1));
assertEquals(7, array.lastIndexOfLong(4));
}
@Test
public void testIndexOfSortedSubArray() throws Exception {
array.sort();
assertEquals(-1, array.offset(1).indexOf(null));
assertEquals(0, array.offset(1).indexOfLong(1));
assertEquals(6, array.offset(1).indexOfLong(4));
}
@Test
public void testLastIndexOfSortedSubArray() throws Exception {
array.sort();
assertEquals(-1, array.offset(1).lastIndexOf(null));
assertEquals(1, array.offset(1).lastIndexOfLong(1));
assertEquals(6, array.offset(1).lastIndexOfLong(4));
}
@Test
public void testGet() throws Exception {
try {
array.getLong(-1);
fail();
} catch (IndexOutOfBoundsException e) {
}
assertEquals(1, array.getLong(0));
assertEquals(1, array.getLong(1));
assertEquals(2, array.getLong(2));
assertEquals(1, array.getLong(3));
assertEquals(2, array.getLong(4));
assertEquals(3, array.getLong(5));
assertEquals(3, array.getLong(6));
assertEquals(4, array.getLong(7));
try {
assertEquals(1, array.getLong(8));
fail();
} catch (IndexOutOfBoundsException e) {
}
assertArrayEquals(new long[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray());
}
@Test
public void testOffset() throws Exception {
try {
array.offset(-1);
fail();
} catch (IndexOutOfBoundsException e) {
}
//noinspection PointlessArithmeticExpression
assertEquals(0 + 1, array.offset(0).offset());
assertEquals(1 + 1, array.offset(1).offset());
assertEquals(2 + 1, array.offset(2).offset());
assertEquals(3 + 1, array.offset(3).offset());
assertEquals(4 + 1, array.offset(4).offset());
assertEquals(5 + 1, array.offset(5).offset());
assertEquals(6 + 1, array.offset(6).offset());
assertEquals(7 + 1, array.offset(7).offset());
assertEquals(8 + 1, array.offset(8).offset());
assertEquals(8, array.offset(0).length());
assertEquals(7, array.offset(1).length());
assertEquals(6, array.offset(2).length());
assertEquals(5, array.offset(3).length());
assertEquals(4, array.offset(4).length());
assertEquals(3, array.offset(5).length());
assertEquals(2, array.offset(6).length());
assertEquals(1, array.offset(7).length());
assertEquals(0, array.offset(8).length());
try {
array.offset(9);
fail();
} catch (IndexOutOfBoundsException e) {
}
MutableLongArray array2 = array.subArray(2, array.length());
assertEquals(2 + 1, array2.offset());
assertArrayEquals(new long[]{2, 1, 2, 3, 3, 4}, array2.toArray());
}
@Test
public void testIterator() {
List<Long> list = new ArrayList<>();
//noinspection ForLoopReplaceableByForEach
for (Iterator<Long> it = array.iterator(); it.hasNext();) {
list.add(it.next());
}
assertArrayEquals(new Long[]{1L, 1L, 2L, 1L, 2L, 3L, 3L, 4L}, list.toArray());
}
@Test
public void testSubArrayIterator() {
List<Long> list = new ArrayList<>();
//noinspection ForLoopReplaceableByForEach
for (Iterator<Long> it = array.subArray(2, 5).iterator(); it.hasNext();) {
list.add(it.next());
}
assertArrayEquals(new Long[]{2L, 1L, 2L}, list.toArray());
}
@Test
public void testIteratorRemove() throws Exception {
int length = array.length();
try {
for (Iterator<Long> i = array.iterator(); i.hasNext();) {
i.next();
i.remove();
}
fail();
} catch (UnsupportedOperationException e) {
}
assertEquals(length, array.length());
}
@Test
public void testArrayIterator() {
List<Long> list = new ArrayList<>();
//noinspection ForLoopReplaceableByForEach
for (Iterator<Long> it = array.iterator(1); it.hasNext();) {
list.add(it.next());
}
assertArrayEquals(new Long[]{1L, 2L, 1L, 2L, 3L, 3L, 4L}, list.toArray());
}
@Test
public void testSubArrayArrayIterator() {
List<Long> list = new ArrayList<>();
//noinspection ForLoopReplaceableByForEach
for (Iterator<Long> it = array.subArray(2, 5).iterator(1); it.hasNext();) {
list.add(it.next());
}
assertArrayEquals(new Long[]{1L, 2L}, list.toArray());
}
@Test
public void testArrayIteratorRemove() throws Exception {
int length = array.length();
try {
for (Iterator<Long> i = array.iterator(1); i.hasNext();) {
i.next();
i.remove();
}
fail();
} catch (UnsupportedOperationException e) {
}
assertEquals(length, array.length());
}
private static MutableLongArray serializeAndDeserialize(MutableLongArray array) throws IOException, ClassNotFoundException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try (ObjectOutputStream os = new ObjectOutputStream(bos)) {
os.writeObject(array);
}
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
try (ObjectInputStream is = new ObjectInputStream(bis)) {
return (MutableLongArray) is.readObject();
}
}
}