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.CharBuffer;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
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;
import static org.squarebrackets.ArrayCharacteristics.DISTINCT;
import static org.squarebrackets.ArrayCharacteristics.SORTED;
/**
* @author Leon van Zantvoort
*/
@SuppressWarnings({"MissingMethodJavaDoc", "MissingFieldJavaDoc"})
public class BoundedCharBufferArrayTest {
private BoundedCharArray array;
@Before
public void setUp() throws Exception {
char[] a = new char[] {0, 1, 1, 2, 1, 2, 3, 3, 4, 0, 0};
CharBuffer buffer = CharBuffer.wrap(a, 1, 8);
array = BoundedCharArray.valueOf(buffer);
array = serializeAndDeserialize(array); // Test serialization.
char[] b = new char[11];
array.toArray(b, 1, 8);
buffer = CharBuffer.wrap(b, 1, 8);
array = BoundedCharArray.valueOf(buffer);
array = Arrays.synchronizedArray(array, array); // Test synchronized array.
}
@Test
public void nullable() {
assertTrue(array.hasCharacteristics(ArrayCharacteristics.NONNULL));
}
@Test
public void mutable() {
assertTrue(array.hasCharacteristics(ArrayCharacteristics.MUTABLE));
}
@Test
public void resizable() {
assertTrue(array.hasCharacteristics(ArrayCharacteristics.RESIZABLE));
}
@Test
public void replaceable() {
assertFalse(array.hasCharacteristics(ArrayCharacteristics.REPLACEABLE));
}
@Test
public void copyFactory() throws Exception {
UnboundedCharArray d = UnboundedCharArray.copyOf(array);
d.setChar(0, (char) 0);
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray());
assertArrayEquals(new char[]{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 testRemainingCapacity() {
assertEquals(2, array.remainingCapacity());
}
@Test
public void testSetAll() throws Exception {
UnboundedCharArray smaller = UnboundedCharArray.copyOf(array);
smaller.charRemove();
array.setAll(smaller);
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3}, array.toArray());
array.addChar((char) 4);
MutableCharArray backedByArray = MutableCharArray.copyOf(array);
Arrays.reverse(backedByArray);
array.setAll(backedByArray);
assertArrayEquals(new char[]{4, 3, 3, 2, 1, 2, 1, 1}, array.toArray());
CharBuffer buffer = ByteBuffer.allocateDirect(Character.SIZE / Byte.SIZE * 8).asCharBuffer();
MutableCharArray notBackedByArray = Arrays.newMutableArray(buffer);
notBackedByArray.setAll(backedByArray);
array.setAll(notBackedByArray);
assertArrayEquals(new char[]{4, 3, 3, 2, 1, 2, 1, 1}, array.toArray());
UnboundedCharArray bigger = UnboundedCharArray.copyOf(array);
bigger.addChar((char) 0);
array.setAll(bigger);
assertArrayEquals(new char[]{4, 3, 3, 2, 1, 2, 1, 1, 0}, array.toArray());
bigger.addChar((char) 0);
array.setAll(bigger);
assertArrayEquals(new char[]{4, 3, 3, 2, 1, 2, 1, 1, 0, 0}, array.toArray());
bigger.addChar((char) 0);
try {
array.setAll(bigger);
fail();
} catch (IllegalStateException ignore) {
}
assertArrayEquals(new char[]{4, 3, 3, 2, 1, 2, 1, 1, 0, 0}, array.toArray());
}
@Test
public void testContains() throws Exception {
assertTrue(array.containsChar((char) 1));
assertTrue(array.containsChar((char) 4));
assertFalse(array.containsChar((char) 5));
assertFalse(array.length(7).containsChar((char) 4));
assertFalse(array.contains(null));
}
@Test
public void testContainsObject() throws Exception {
assertTrue(array.contains((char) 1));
assertTrue(array.contains((char) 4));
assertFalse(array.contains((char) 5));
assertFalse(array.length(7).contains((char) 4));
assertFalse(array.contains(null));
}
@Test
public void testContainsSorted() throws Exception {
array.sort();
assertTrue(array.containsChar((char) 1));
assertTrue(array.containsChar((char) 4));
assertFalse(array.containsChar((char) 5));
assertFalse(array.length(7).containsChar((char) 4));
assertFalse(array.contains(null));
}
@Test
public void testContainsAll() throws Exception {
MutableCharArray testTrue = MutableCharArray.valueOf(new char[]{1, 2, 3});
MutableCharArray testFalse = MutableCharArray.valueOf(new char[]{3, 4, 5});
assertTrue(array.containsAll(testTrue));
assertFalse(array.length(5).containsAll(testTrue));
assertFalse(array.containsAll(testFalse));
UnboundedObjectArray<Character> objectTestTrue = UnboundedObjectArray.valueOf((char) 1, (char) 2, (char) 3);
assertTrue(array.containsAll(objectTestTrue));
UnboundedObjectArray<Character> objectTestFalse = UnboundedObjectArray.valueOf((char) 3, (char) 4, (char) 5);
assertFalse(array.containsAll(objectTestFalse));
UnboundedObjectArray<Integer> objectTestOther = UnboundedObjectArray.valueOf(1, 2, 3);
assertFalse(array.containsAll(objectTestOther));
}
@Test
public void testContainsAllSorted() throws Exception {
array.sort();
MutableCharArray testTrue = MutableCharArray.valueOf(new char[]{1, 2, 3});
testTrue.sort();
MutableCharArray testFalse = MutableCharArray.valueOf(new char[]{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.indexOfChar((char) 1));
assertEquals(7, array.indexOfChar((char) 4));
}
@Test
public void testLastIndexOf() throws Exception {
assertEquals(-1, array.lastIndexOf(null));
assertEquals(3, array.lastIndexOfChar((char) 1));
assertEquals(7, array.lastIndexOfChar((char) 4));
}
@Test
public void testIndexOfSubArray() throws Exception {
assertEquals(-1, array.offset(1).indexOf(null));
assertEquals(0, array.offset(1).indexOfChar((char) 1));
assertEquals(6, array.offset(1).indexOfChar((char) 4));
}
@Test
public void testLastIndexOfSubArray() throws Exception {
assertEquals(-1, array.offset(1).lastIndexOf(null));
assertEquals(2, array.offset(1).lastIndexOfChar((char) 1));
assertEquals(6, array.offset(1).lastIndexOfChar((char) 4));
}
@Test
public void testIndexOfSorted() throws Exception {
array.sort();
assertEquals(-1, array.indexOf(null));
assertEquals(0, array.indexOfChar((char) 1));
assertEquals(7, array.indexOfChar((char) 4));
}
@Test
public void testLastIndexOfSorted() throws Exception {
array.sort();
assertEquals(-1, array.lastIndexOf(null));
assertEquals(2, array.lastIndexOfChar((char) 1));
assertEquals(7, array.lastIndexOfChar((char) 4));
}
@Test
public void testIndexOfSortedSubArray() throws Exception {
array.sort();
assertEquals(-1, array.offset(1).indexOf(null));
assertEquals(0, array.offset(1).indexOfChar((char) 1));
assertEquals(6, array.offset(1).indexOfChar((char) 4));
}
@Test
public void testLastIndexOfSortedSubArray() throws Exception {
array.sort();
assertEquals(-1, array.offset(1).lastIndexOf(null));
assertEquals(1, array.offset(1).lastIndexOfChar((char) 1));
assertEquals(6, array.offset(1).lastIndexOfChar((char) 4));
}
@Test
public void testGet() throws Exception {
try {
array.getChar(-1);
fail();
} catch (IndexOutOfBoundsException e) {
}
assertEquals(1, array.getChar(0));
assertEquals(1, array.getChar(1));
assertEquals(2, array.getChar(2));
assertEquals(1, array.getChar(3));
assertEquals(2, array.getChar(4));
assertEquals(3, array.getChar(5));
assertEquals(3, array.getChar(6));
assertEquals(4, array.getChar(7));
try {
assertEquals(1, array.getChar(8));
fail();
} catch (IndexOutOfBoundsException e) {
}
assertArrayEquals(new char[]{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(4 + 1, array.offset(4).offset());
assertEquals(3 + 1, array.offset(3).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) {
}
MutableCharArray array2 = array.subArray(2, array.length());
assertEquals(2 + 1, array2.offset());
assertArrayEquals(new char[]{2, 1, 2, 3, 3, 4}, array2.toArray());
}
@Test
public void testIterator() {
List<Character> list = new ArrayList<>();
//noinspection ForLoopReplaceableByForEach
for (Iterator<Character> it = array.iterator(); it.hasNext();) {
list.add(it.next());
}
assertArrayEquals(new Character[]{1, 1, 2, 1, 2, 3, 3, 4}, list.toArray());
}
@Test
public void testSubArrayIterator() {
List<Character> list = new ArrayList<>();
//noinspection ForLoopReplaceableByForEach
for (Iterator<Character> it = array.subArray(2, 5).iterator(); it.hasNext();) {
list.add(it.next());
}
assertArrayEquals(new Character[]{2, 1, 2}, list.toArray());
}
@Test
public void testIteratorRemove() throws Exception {
int length = array.length();
try {
for (Iterator<Character> i = array.iterator(); i.hasNext();) {
i.next();
i.remove();
}
fail();
} catch (UnsupportedOperationException e) {
}
assertEquals(length, array.length());
}
@Test
public void testArrayIterator() {
List<Character> list = new ArrayList<>();
//noinspection ForLoopReplaceableByForEach
for (Iterator<Character> it = array.iterator(1); it.hasNext();) {
list.add(it.next());
}
assertArrayEquals(new Character[]{1, 2, 1, 2, 3, 3, 4}, list.toArray());
}
@Test
public void testSubArrayArrayIterator() {
List<Character> list = new ArrayList<>();
//noinspection ForLoopReplaceableByForEach
for (Iterator<Character> it = array.subArray(2, 5).iterator(1); it.hasNext();) {
list.add(it.next());
}
assertArrayEquals(new Character[]{1, 2}, list.toArray());
}
@Test
public void testArrayIteratorRemove() throws Exception {
int length = array.length();
try {
for (Iterator<Character> i = array.iterator(1); i.hasNext();) {
i.next();
i.remove();
}
fail();
} catch (UnsupportedOperationException e) {
}
assertEquals(length, array.length());
}
@Test
public void testAdd() throws Exception {
array.addChar((char) 5);
assertEquals(9, array.length());
array.addChar((char) 5);
assertEquals(10, array.length());
try {
array.addChar((char) 5);
fail();
} catch (IllegalStateException ignore) {
}
assertEquals(10, array.length());
}
@Test
public void testAddAll0() throws Exception {
array.addAll(CharArray.unsafeValueOf());
assertEquals(8, array.length());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray());
}
@Test
public void testAddAll1() throws Exception {
array.addAll(CharArray.unsafeValueOf((char) 5));
assertEquals(9, array.length());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4, 5}, array.toArray());
}
@Test
public void testAddAll2() throws Exception {
array.addAll(CharArray.unsafeValueOf((char) 5, (char) 5));
assertEquals(10, array.length());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4, 5, 5}, array.toArray());
}
@Test
public void testAddAll3() throws Exception {
try {
array.addAll(CharArray.unsafeValueOf((char) 5, (char) 5, (char) 5));
fail();
} catch (IllegalStateException ignore) {
}
assertEquals(8, array.length());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray());
}
@Test
public void testAddAllNoBackingArray0() throws Exception {
CharBuffer buffer = ByteBuffer.allocateDirect(Character.SIZE / Byte.SIZE * 10).asCharBuffer();
buffer.position(1).limit(9);
BoundedCharArray notBackedByArray = BoundedCharArray.valueOf(buffer);
notBackedByArray.setAll(array);
notBackedByArray.addAll(CharArray.unsafeValueOf());
assertEquals(8, notBackedByArray.length());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4}, notBackedByArray.toArray());
}
@Test
public void testAddAllNoBackingArray1() throws Exception {
CharBuffer buffer = ByteBuffer.allocateDirect(Character.SIZE / Byte.SIZE * 11).asCharBuffer();
buffer.position(1).limit(9);
BoundedCharArray notBackedByArray = BoundedCharArray.valueOf(buffer);
notBackedByArray.setAll(array);
notBackedByArray.addAll(CharArray.unsafeValueOf((char) 5));
assertEquals(9, notBackedByArray.length());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4, 5}, notBackedByArray.toArray());
}
@Test
public void testAddAllNoBackingArray2() throws Exception {
CharBuffer buffer = ByteBuffer.allocateDirect(Character.SIZE / Byte.SIZE * 11).asCharBuffer();
buffer.position(1).limit(9);
BoundedCharArray notBackedByArray = BoundedCharArray.valueOf(buffer);
notBackedByArray.setAll(array);
notBackedByArray.addAll(CharArray.unsafeValueOf((char) 5, (char) 5));
assertEquals(10, notBackedByArray.length());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4, 5, 5}, notBackedByArray.toArray());
}
@Test
public void testAddAllNoBackingArray3() throws Exception {
CharBuffer buffer = ByteBuffer.allocateDirect(Character.SIZE / Byte.SIZE * 11).asCharBuffer();
buffer.position(1).limit(9);
BoundedCharArray notBackedByArray = BoundedCharArray.valueOf(buffer);
notBackedByArray.setAll(array);
try {
notBackedByArray.addAll(CharArray.unsafeValueOf((char) 5, (char) 5, (char) 5));
fail();
} catch (IllegalStateException ignore) {
}
assertEquals(8, notBackedByArray.length());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4}, notBackedByArray.toArray());
}
@Test
public void testAddSubArrayConcurrentModification1() throws Exception {
BoundedCharArray sub = array.offset(0);
array.addChar((char) 5);
assertEquals(array.length() - 1, sub.length());
try {
sub.iterator();
fail();
} catch (ConcurrentModificationException ignore) {
}
}
@Test
public void testAddSubArrayConcurrentModification2() throws Exception {
MutableCharArray sub = array.length(array.length());
array.addChar((char) 5);
assertEquals(array.length() - 1, sub.length());
try {
sub.iterator();
fail();
} catch (ConcurrentModificationException ignore) {
}
}
@Test
public void testAddSubArrayConcurrentModification3() throws Exception {
MutableCharArray sub = array.subArray(0, array.length());
array.addChar((char) 5);
assertEquals(array.length() - 1, sub.length());
try {
sub.iterator();
fail();
} catch (ConcurrentModificationException ignore) {
}
}
@Test
public void testAddSubArray() throws Exception {
BoundedCharArray sub = array.offset(1);
sub.addChar((char) 5);
assertArrayEquals(new char[]{1, 2, 1, 2, 3, 3, 4, 5}, sub.toArray());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4, 5}, array.toArray());
}
@Test
public void testAddAllSubArray() throws Exception {
BoundedCharArray sub = array.offset(1);
sub.addAll(CharArray.copyOf((char) 5, (char) 6));
assertArrayEquals(new char[]{1, 2, 1, 2, 3, 3, 4, 5, 6}, sub.toArray());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3, 4, 5, 6}, array.toArray());
}
@Test
public void testRemove() throws Exception {
assertEquals(4, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3}, array.toArray());
assertEquals(3, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3}, array.toArray());
assertEquals(3, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2, 1, 2}, array.toArray());
assertEquals(2, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2, 1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2}, array.toArray());
assertEquals(2, array.charRemove());
assertArrayEquals(new char[]{1, 1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{}, array.toArray());
try {
array.charRemove();
fail();
} catch (NoSuchElementException e) {
}
}
@Test
public void testRemoveClearReservedElements() throws Exception {
array.setClearReservedElements(true);
assertEquals(4, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3, 3}, array.toArray());
assertEquals(3, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2, 1, 2, 3}, array.toArray());
assertEquals(3, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2, 1, 2}, array.toArray());
assertEquals(2, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2, 1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{1, 1, 2}, array.toArray());
assertEquals(2, array.charRemove());
assertArrayEquals(new char[]{1, 1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{}, array.toArray());
try {
array.charRemove();
fail();
} catch (NoSuchElementException e) {
}
}
@Test
public void testRemoveSort() throws Exception {
array.sort();
assertEquals(4, array.charRemove());
assertArrayEquals(new char[]{1, 1, 1, 2, 2, 3, 3}, array.toArray());
assertEquals(3, array.charRemove());
assertArrayEquals(new char[]{1, 1, 1, 2, 2, 3}, array.toArray());
assertEquals(3, array.charRemove());
assertArrayEquals(new char[]{1, 1, 1, 2, 2}, array.toArray());
assertEquals(2, array.charRemove());
assertArrayEquals(new char[]{1, 1, 1, 2}, array.toArray());
assertEquals(2, array.charRemove());
assertArrayEquals(new char[]{1, 1, 1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{1, 1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{1}, array.toArray());
assertEquals(1, array.charRemove());
assertArrayEquals(new char[]{}, array.toArray());
try {
array.charRemove();
fail();
} catch (NoSuchElementException e) {
}
}
@Test
public void testClear() throws Exception {
int offset = array.offset();
array.clear();
assertArrayEquals(new char[]{}, array.toArray());
assertEquals(0, array.length());
assertEquals(offset, array.offset());
}
@Test
public void testSetAllReservedElements() throws Exception {
array.setClearReservedElements(true);
int offset = array.offset();
array.setAll(CharArray.unsafeValueOf());
assertArrayEquals(new char[]{}, array.toArray());
assertEquals(0, array.length());
assertEquals(offset, array.offset());
CharBuffer buffer = array.buffer();
buffer.rewind().limit(buffer.capacity());
while (buffer.hasRemaining()) {
assertEquals(0, buffer.get());
}
}
@Test
public void testRemoveElements() throws Exception {
array.setClearReservedElements(true);
int offset = array.offset();
while (!array.isEmpty()) {
array.charRemove();
}
assertArrayEquals(new char[]{}, array.toArray());
assertEquals(0, array.length());
assertEquals(offset, array.offset());
CharBuffer buffer = array.buffer();
buffer.rewind().limit(buffer.capacity());
while (buffer.hasRemaining()) {
assertEquals(0, buffer.get());
}
}
@Test
public void testClearReservedElements() throws Exception {
array.setClearReservedElements(true);
int offset = array.offset();
array.clear();
assertArrayEquals(new char[]{}, array.toArray());
assertEquals(0, array.length());
assertEquals(offset, array.offset());
CharBuffer buffer = array.buffer();
buffer.rewind().limit(buffer.capacity());
while (buffer.hasRemaining()) {
assertEquals(0, buffer.get());
}
}
@Test
public void testCharacteristics() {
assertFalse(array.hasCharacteristics(SORTED));
assertFalse(array.hasCharacteristics(DISTINCT));
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
array.clear();
assertArrayEquals(new char[]{}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertTrue(array.hasCharacteristics(DISTINCT));
assertTrue(array.hasCharacteristics(SORTED | DISTINCT));
array.addChar((char) 1);
array.addChar((char) 1);
array.addChar((char) 1);
array.addChar((char) 2);
array.addChar((char) 2);
array.addChar((char) 3);
array.addChar((char) 3);
array.addChar((char) 4);
assertArrayEquals(new char[]{1, 1, 1, 2, 2, 3, 3, 4}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertFalse(array.hasCharacteristics(DISTINCT));
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsAdd() {
array.clear();
array.addChar((char) 0);
array.addChar((char) 1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 2);
a.addChar((char) 3);
a.addChar((char) 4);
array.addAll(a);
assertArrayEquals(new char[]{0, 1, 2, 3, 4}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertTrue(array.hasCharacteristics(DISTINCT));
assertTrue(array.hasCharacteristics(SORTED | DISTINCT));
UnboundedCharArray b = UnboundedCharArray.newInstance();
b.addChar((char) 4);
b.addChar((char) 5);
b.addChar((char) 6);
array.addAll(b);
assertArrayEquals(new char[]{0, 1, 2, 3, 4, 4, 5, 6}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertFalse(array.hasCharacteristics(DISTINCT));
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSubArrayAdd1() {
array.clear();
array.addChar((char) 0);
array.addChar((char) 1);
BoundedCharArray sub = array.offset(1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 2);
a.addChar((char) 3);
a.addChar((char) 4);
sub.addAll(a);
assertArrayEquals(new char[]{1, 2, 3, 4}, sub.toArray());
assertTrue(sub.hasCharacteristics(SORTED));
assertTrue(sub.hasCharacteristics(DISTINCT));
assertTrue(sub.hasCharacteristics(SORTED | DISTINCT));
assertArrayEquals(new char[]{0, 1, 2, 3, 4}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertTrue(array.hasCharacteristics(DISTINCT));
assertTrue(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSubArrayAdd2() {
array.clear();
array.addChar((char) 1);
array.addChar((char) 1);
BoundedCharArray sub = array.offset(1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 2);
a.addChar((char) 3);
a.addChar((char) 4);
sub.addAll(a);
assertArrayEquals(new char[]{1, 2, 3, 4}, sub.toArray());
assertTrue(sub.hasCharacteristics(SORTED));
assertTrue(sub.hasCharacteristics(DISTINCT));
assertTrue(sub.hasCharacteristics(SORTED | DISTINCT));
assertArrayEquals(new char[]{1, 1, 2, 3, 4}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertFalse(array.hasCharacteristics(DISTINCT));
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSubArrayAdd3() {
array.clear();
array.addChar((char) 0);
array.addChar((char) 1);
BoundedCharArray sub = array.offset(1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 2);
a.addChar((char) 3);
a.addChar((char) 3);
sub.addAll(a);
assertArrayEquals(new char[]{1, 2, 3, 3}, sub.toArray());
assertTrue(sub.hasCharacteristics(SORTED));
assertFalse(sub.hasCharacteristics(DISTINCT));
assertFalse(sub.hasCharacteristics(SORTED | DISTINCT));
assertArrayEquals(new char[]{0, 1, 2, 3, 3}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertFalse(array.hasCharacteristics(DISTINCT));
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSubArrayAdd4() {
array.clear();
array.addChar((char) 0);
array.addChar((char) 4);
BoundedCharArray sub = array.offset(1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 0);
a.addChar((char) 1);
a.addChar((char) 2);
sub.addAll(a);
assertArrayEquals(new char[]{4, 0, 1, 2}, sub.toArray());
assertFalse(sub.hasCharacteristics(SORTED));
// Array not sorted anymore, cannot asses distinct status.
assertFalse(sub.hasCharacteristics(SORTED | DISTINCT));
assertArrayEquals(new char[]{0, 4, 0, 1, 2}, array.toArray());
assertFalse(array.hasCharacteristics(SORTED));
assertFalse(array.hasCharacteristics(DISTINCT));
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSubArrayAdd5() {
array.clear();
array.addChar((char) 4);
array.addChar((char) 5);
BoundedCharArray sub = array.offset(1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 0);
a.addChar((char) 1);
a.addChar((char) 2);
sub.addAll(a);
assertArrayEquals(new char[]{5, 0, 1, 2}, sub.toArray());
assertFalse(sub.hasCharacteristics(SORTED));
// Array not sorted anymore, cannot asses distinct status.
assertFalse(sub.hasCharacteristics(SORTED | DISTINCT));
assertArrayEquals(new char[]{4, 5, 0, 1, 2}, array.toArray());
assertFalse(array.hasCharacteristics(SORTED));
// Array not sorted anymore, cannot asses distinct status.
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSet() {
array.clear();
array.addChar((char) 0);
array.addChar((char) 4);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 1);
a.addChar((char) 2);
a.addChar((char) 3);
array.setAll(a);
assertArrayEquals(new char[]{1, 2, 3}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertTrue(array.hasCharacteristics(DISTINCT));
assertTrue(array.hasCharacteristics(SORTED | DISTINCT));
UnboundedCharArray b = UnboundedCharArray.newInstance();
b.addChar((char) 4);
b.addChar((char) 5);
b.addChar((char) 6);
array.setAll(b);
assertArrayEquals(new char[]{4, 5, 6}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertTrue(array.hasCharacteristics(DISTINCT));
assertTrue(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSubArraySet1() {
array.clear();
array.addChar((char) 0);
array.addChar((char) 2);
array.addChar((char) 4);
BoundedCharArray sub = array.offset(1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 1);
a.addChar((char) 2);
a.addChar((char) 3);
sub.setAll(a);
assertArrayEquals(new char[]{1, 2, 3}, sub.toArray());
assertTrue(sub.hasCharacteristics(SORTED));
assertTrue(sub.hasCharacteristics(DISTINCT));
assertTrue(sub.hasCharacteristics(SORTED | DISTINCT));
assertArrayEquals(new char[]{0, 1, 2, 3}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertTrue(array.hasCharacteristics(DISTINCT));
assertTrue(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSubArraySet2() {
array.clear();
array.addChar((char) 2);
array.addChar((char) 3);
array.addChar((char) 4);
BoundedCharArray sub = array.offset(1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 1);
a.addChar((char) 2);
a.addChar((char) 3);
sub.setAll(a);
assertArrayEquals(new char[]{1, 2, 3}, sub.toArray());
assertTrue(sub.hasCharacteristics(SORTED));
assertTrue(sub.hasCharacteristics(DISTINCT));
assertTrue(sub.hasCharacteristics(SORTED | DISTINCT));
assertArrayEquals(new char[]{2, 1, 2, 3}, array.toArray());
assertFalse(array.hasCharacteristics(SORTED));
assertFalse(array.hasCharacteristics(DISTINCT));
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
}
@Test
public void testCharacteristicsSubArraySet3() {
array.clear();
array.addChar((char) 1);
array.addChar((char) 2);
array.addChar((char) 4);
BoundedCharArray sub = array.offset(1);
UnboundedCharArray a = UnboundedCharArray.newInstance();
a.addChar((char) 1);
a.addChar((char) 2);
a.addChar((char) 3);
sub.setAll(a);
assertArrayEquals(new char[]{1, 2, 3}, sub.toArray());
assertTrue(sub.hasCharacteristics(SORTED));
assertTrue(sub.hasCharacteristics(DISTINCT));
assertTrue(sub.hasCharacteristics(SORTED | DISTINCT));
assertArrayEquals(new char[]{1, 1, 2, 3}, array.toArray());
assertTrue(array.hasCharacteristics(SORTED));
assertFalse(array.hasCharacteristics(DISTINCT));
assertFalse(array.hasCharacteristics(SORTED | DISTINCT));
}
private static BoundedCharArray serializeAndDeserialize(BoundedCharArray 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 (BoundedCharArray) is.readObject();
}
}
}