Package org.squarebrackets

Source Code of org.squarebrackets.MutableDoubleBufferArrayTest

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.DoubleBuffer;
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 MutableDoubleBufferArrayTest {

    private MutableDoubleArray array;

    @Before
    public void setUp() throws Exception {
        double[] a = new double[] {0, 0, 1, 1, 2, 1, 2, 3, 3, 4};
        DoubleBuffer buffer = DoubleBuffer.wrap(a, 1, 9);
        array = MutableDoubleArray.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 {
        UnboundedDoubleArray d = UnboundedDoubleArray.copyOf(array);
        d.setDouble(0, (double) 0);
        assertArrayEquals(new double[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray(), 0);
        assertArrayEquals(new double[]{0, 1, 2, 1, 2, 3, 3, 4}, d.toArray(), 0);
    }

    @Test
    public void testSerialization() throws Exception {
        Array<?> a = serializeAndDeserialize(array);
        assertEquals(array, a);
    }

    @Test
    public void testSetAll() throws Exception {
        UnboundedDoubleArray smaller = UnboundedDoubleArray.copyOf(array);
        smaller.doubleRemove();
        try {
            array.setAll(smaller);
            fail();
        } catch (IllegalStateException ignore) {
        }
        assertArrayEquals(new double[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray(), 0);
        MutableDoubleArray backedByArray = MutableDoubleArray.copyOf(array);
        Arrays.reverse(backedByArray);
        array.setAll(backedByArray);
        assertArrayEquals(new double[]{4, 3, 3, 2, 1, 2, 1, 1}, array.toArray(), 0);
        DoubleBuffer buffer = ByteBuffer.allocateDirect(Double.SIZE / Byte.SIZE * 8).asDoubleBuffer();
        MutableDoubleArray notBackedByArray = Arrays.newMutableArray(buffer);
        notBackedByArray.setAll(backedByArray);
        array.setAll(notBackedByArray);
        assertArrayEquals(new double[]{4, 3, 3, 2, 1, 2, 1, 1}, array.toArray(), 0);
        UnboundedDoubleArray tooBig = UnboundedDoubleArray.copyOf(array);
        tooBig.addDouble(0);
        try {
            array.setAll(tooBig);
            fail();
        } catch (IllegalStateException ignore) {
        }
        assertArrayEquals(new double[]{4, 3, 3, 2, 1, 2, 1, 1}, array.toArray(), 0);
    }

    @Test
    public void testContains() throws Exception {
        assertTrue(array.containsDouble((double) 1));
        assertTrue(array.containsDouble((double) 4));
        assertFalse(array.containsDouble((double) 5));
        assertFalse(array.length(7).containsDouble((double) 4));
        assertFalse(array.contains(null));
    }

    @Test
    public void testContainsObject() throws Exception {
        assertTrue(array.contains((double) 1));
        assertTrue(array.contains((double) 4));
        assertFalse(array.contains((double) 5));
        assertFalse(array.length(7).contains((double) 4));
        assertFalse(array.contains(null));
    }

    @Test
    public void testContainsSorted() throws Exception {
        array.sort();
        assertTrue(array.containsDouble((double) 1));
        assertTrue(array.containsDouble((double) 4));
        assertFalse(array.containsDouble((double) 5));
        assertFalse(array.length(7).containsDouble((double) 4));
        assertFalse(array.contains(null));
    }

    @Test
    public void testContainsAll() throws Exception {
        MutableDoubleArray testTrue = MutableDoubleArray.valueOf(1, 2, 3);
        MutableDoubleArray testFalse = MutableDoubleArray.valueOf(3, 4, 5);
        assertTrue(array.containsAll(testTrue));
        assertFalse(array.length(5).containsAll(testTrue));
        assertFalse(array.containsAll(testFalse));
        UnboundedObjectArray<Double> objectTestTrue = UnboundedObjectArray.valueOf((double) 1, (double) 2, (double) 3);
        assertTrue(array.containsAll(objectTestTrue));
        UnboundedObjectArray<Double> objectTestFalse = UnboundedObjectArray.valueOf((double) 3, (double) 4, (double) 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();
        MutableDoubleArray testTrue = MutableDoubleArray.valueOf(1, 2, 3);
        testTrue.sort();
        MutableDoubleArray testFalse = MutableDoubleArray.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.indexOfDouble((double) 1));
        assertEquals(7, array.indexOfDouble((double) 4));
    }

    @Test
    public void testLastIndexOf() throws Exception {
        assertEquals(-1, array.lastIndexOf(null));
        assertEquals(3, array.lastIndexOfDouble((double) 1));
        assertEquals(7, array.lastIndexOfDouble((double) 4));
    }

    @Test
    public void testIndexOfSubArray() throws Exception {
        assertEquals(-1, array.offset(1).indexOf(null));
        assertEquals(0, array.offset(1).indexOfDouble((double) 1));
        assertEquals(6, array.offset(1).indexOfDouble((double) 4));
    }

    @Test
    public void testLastIndexOfSubArray() throws Exception {
        assertEquals(-1, array.offset(1).lastIndexOf(null));
        assertEquals(2, array.offset(1).lastIndexOfDouble((double) 1));
        assertEquals(6, array.offset(1).lastIndexOfDouble((double) 4));
    }

    @Test
    public void testIndexOfSorted() throws Exception {
        array.sort();
        assertEquals(-1, array.indexOf(null));
        assertEquals(0, array.indexOfDouble((double) 1));
        assertEquals(7, array.indexOfDouble((double) 4));
    }

    @Test
    public void testLastIndexOfSorted() throws Exception {
        array.sort();
        assertEquals(-1, array.lastIndexOf(null));
        assertEquals(2, array.lastIndexOfDouble((double) 1));
        assertEquals(7, array.lastIndexOfDouble((double) 4));
    }

    @Test
    public void testIndexOfSortedSubArray() throws Exception {
        array.sort();
        assertEquals(-1, array.offset(1).indexOf(null));
        assertEquals(0, array.offset(1).indexOfDouble((double) 1));
        assertEquals(6, array.offset(1).indexOfDouble((double) 4));
    }

    @Test
    public void testLastIndexOfSortedSubArray() throws Exception {
        array.sort();
        assertEquals(-1, array.offset(1).lastIndexOf(null));
        assertEquals(1, array.offset(1).lastIndexOfDouble((double) 1));
        assertEquals(6, array.offset(1).lastIndexOfDouble((double) 4));
    }

    @Test
    public void testGet() throws Exception {
        try {
            array.getDouble(-1);
            fail();
        } catch (IndexOutOfBoundsException e) {
        }
        assertEquals(1, array.getDouble(0), 0);
        assertEquals(1, array.getDouble(1), 0);
        assertEquals(2, array.getDouble(2), 0);
        assertEquals(1, array.getDouble(3), 0);
        assertEquals(2, array.getDouble(4), 0);
        assertEquals(3, array.getDouble(5), 0);
        assertEquals(3, array.getDouble(6), 0);
        assertEquals(4, array.getDouble(7), 0);
        try {
            assertEquals(1, array.getDouble(8), 0);
            fail();
        } catch (IndexOutOfBoundsException e) {
        }
        assertArrayEquals(new double[]{1, 1, 2, 1, 2, 3, 3, 4}, array.toArray(), 0);
    }

    @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) {
        }
        MutableDoubleArray array2 = array.subArray(2, array.length());
        assertEquals(2 + 1, array2.offset());
        assertArrayEquals(new double[]{2, 1, 2, 3, 3, 4}, array2.toArray(), 0);
    }

    @Test
    public void testIterator() {
        List<Double> list = new ArrayList<>();
        //noinspection ForLoopReplaceableByForEach
        for (Iterator<Double> it = array.iterator(); it.hasNext();) {
            list.add(it.next());
        }
        assertArrayEquals(new Double[]{1d, 1d, 2d, 1d, 2d, 3d, 3d, 4d}, list.toArray());
    }

    @Test
    public void testSubArrayIterator() {
        List<Double> list = new ArrayList<>();
        //noinspection ForLoopReplaceableByForEach
        for (Iterator<Double> it = array.subArray(2, 5).iterator(); it.hasNext();) {
            list.add(it.next());
        }
        assertArrayEquals(new Double[]{2d, 1d, 2d}, list.toArray());
    }

    @Test
    public void testIteratorRemove() throws Exception {
        int length = array.length();
        try {
            for (Iterator<Double> i = array.iterator(); i.hasNext();) {
                i.next();
                i.remove();
            }
            fail();
        } catch (UnsupportedOperationException e) {
        }
        assertEquals(length, array.length());
    }

    @Test
    public void testArrayIterator() {
        List<Double> list = new ArrayList<>();
        //noinspection ForLoopReplaceableByForEach
        for (Iterator<Double> it = array.iterator(1); it.hasNext();) {
            list.add(it.next());
        }
        assertArrayEquals(new Double[]{1d, 2d, 1d, 2d, 3d, 3d, 4d}, list.toArray());
    }

    @Test
    public void testSubArrayArrayIterator() {
        List<Double> list = new ArrayList<>();
        //noinspection ForLoopReplaceableByForEach
        for (Iterator<Double> it = array.subArray(2, 5).iterator(1); it.hasNext();) {
            list.add(it.next());
        }
        assertArrayEquals(new Double[]{1d, 2d}, list.toArray());
    }

    @Test
    public void testArrayIteratorRemove() throws Exception {
        int length = array.length();
        try {
            for (Iterator<Double> i = array.iterator(1); i.hasNext();) {
                i.next();
                i.remove();
            }
            fail();
        } catch (UnsupportedOperationException e) {
        }
        assertEquals(length, array.length());
    }

    private static MutableDoubleArray serializeAndDeserialize(MutableDoubleArray 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 (MutableDoubleArray) is.readObject();
        }
    }
}
TOP

Related Classes of org.squarebrackets.MutableDoubleBufferArrayTest

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.