@Test(expectedExceptions = ArrayIndexOutOfBoundsException.class) public void subSeqOutOtBounds1() { MSeq.of(1, 2, 3).subSeq(5); }
@Test(expectedExceptions = IndexOutOfBoundsException.class) public void mseqSubSeqOutOfBounds1() { MSeq.empty().subSeq(-1); }
@Test(expectedExceptions = IllegalArgumentException.class) public void mseqSubSeqOutOfBounds2() { MSeq.empty().subSeq(1); }
@Test(expectedExceptions = ArrayIndexOutOfBoundsException.class) public void subSeqOutOtBounds2() { MSeq.of(1, 2, 3).subSeq(-5); }
@Test(expectedExceptions = ArrayIndexOutOfBoundsException.class) public void subSeqOutOtBounds4() { MSeq.of(1, 2, 3).subSeq(0, 10); }
@Test(expectedExceptions = ArrayIndexOutOfBoundsException.class) public void subSeqOutOtBounds5() { MSeq.of(1, 2, 3).subSeq(-5, 2); }
@Test(dataProvider = "sequences") public void sortWithStart(final MSeq<Integer> seq) { seq.shuffle(new Random(23)); Assert.assertFalse(seq.isSorted()); seq.sort(2); Assert.assertTrue(seq.subSeq(2).isSorted()); Assert.assertFalse(seq.isSorted()); }
@Test public void sliceIndexOf() { final MSeq<Integer> proxy = MSeq.ofLength(1000); for (int i = 0; i < proxy.length(); ++i) { proxy.set(i, i); } final int sliceStart = 50; final int sliceEnd = 500; final MSeq<Integer> slice = proxy.subSeq(sliceStart, sliceEnd); final List<Integer> list = new SeqList<>(slice); for (int i = 0; i < list.size(); ++i) { final int index = list.indexOf(sliceStart + i); Assert.assertEquals(index, i); } }
@Test public void sliceLastIndexOf() { final MSeq<Integer> proxy = MSeq.ofLength(1000); for (int i = 0; i < proxy.length(); ++i) { proxy.set(i, i); } final int sliceStart = 50; final int sliceEnd = 500; final MSeq<Integer> slice = proxy.subSeq(sliceStart, sliceEnd); final List<Integer> list = new SeqList<>(slice); for (int i = 0; i < list.size(); ++i) { final int index = list.lastIndexOf(sliceStart + i); Assert.assertEquals(index, i); } }
@Test(dataProvider = "sequences") public void sortWithEnd(final MSeq<Integer> seq) { seq.shuffle(new Random(23)); Assert.assertFalse(seq.isSorted()); seq.sort(0, seq.length() - 2); Assert.assertTrue(seq.subSeq(0, seq.length() - 2).isSorted()); Assert.assertFalse(seq.isSorted()); }
@DataProvider(name = "subSequences") public Object[][] subSequences() { final MSeq<Integer> mseq = MSeq.ofLength(20); for (int i = 0; i < mseq.length(); ++i) { mseq.set(i, i + 1); } final List<MSeq<Integer>> sequences = new ArrayList<>(); MSeq<Integer> next = mseq; for (int i = 3; i < mseq.length(); ++i) { sequences.add(next); next = next.subSeq(1); } return sequences.stream() .map(s -> new Object[]{Named.of(s.toString(","), s)}) .toArray(Object[][]::new); }
@Test public void sliceGet() { final MSeq<Integer> proxy = MSeq.ofLength(1000); for (int i = 0; i < proxy.length(); ++i) { proxy.set(i, i); } final int sliceStart = 50; final int sliceEnd = 500; final MSeq<Integer> slice = proxy.subSeq(sliceStart, sliceEnd); final List<Integer> list = new SeqList<>(slice); for (int i = 0; i < list.size(); ++i) { Assert.assertEquals(slice.get(i), Integer.valueOf(i + sliceStart)); } }
@Test public void subSeqEmptyMSeq() { Assert.assertSame(MSeq.of(1, 2, 3).subSeq(3), MSeq.empty()); Assert.assertSame(MSeq.of(1, 2, 3).subSeq(3, 3), MSeq.empty()); Assert.assertSame(MSeq.of(1, 2, 3).subSeq(2, 2), MSeq.empty()); Assert.assertSame(MSeq.of(1, 2, 3).subSeq(1, 1), MSeq.empty()); Assert.assertSame(MSeq.of(1, 2, 3).subSeq(0, 0), MSeq.empty()); }
@Test(dataProvider = "subSequences") public void subSeqImmutable(final Named<MSeq<Integer>> parameter) { final MSeq<Integer> seq = parameter.value; final Integer second = seq.get(1); final MSeq<Integer> slice = seq.subSeq(1); Assert.assertEquals(slice.get(0), second); final ISeq<Integer> islice = slice.toISeq(); Assert.assertEquals(islice.get(0), second); final Integer newSecond = -22; seq.set(1, newSecond); Assert.assertEquals(slice.get(0), newSecond); Assert.assertEquals(islice.get(0), second); }
return front.subSeq(0, n).copy().toISeq();
crossover.crossover(g1c, g2c); Assert.assertEquals(g1c.subSeq(0, rv1), g1.subSeq(0, rv1)); Assert.assertEquals(g1c.subSeq(rv1), g2.subSeq(rv1)); Assert.assertNotEquals(g1c, g2); Assert.assertNotEquals(g2c, g1); Assert.assertEquals(g1c2, g2); Assert.assertEquals(g2c2, g1); Assert.assertEquals(g1c2.subSeq(0, rv2), g1.subSeq(0, rv2)); Assert.assertEquals(g1c2.subSeq(rv2), g2.subSeq(rv2)); MSeq<CharacterGene> g2c3 = g2.copy(); crossover.crossover(g1c3, g2c3); Assert.assertEquals(g1c3.subSeq(0, rv3), g1.subSeq(0, rv3)); Assert.assertEquals(g1c3.subSeq(rv3), g2.subSeq(rv3)); Assert.assertEquals(g1c4, g1); Assert.assertEquals(g2c4, g2); Assert.assertEquals(g1c4.subSeq(0, rv4), g1.subSeq(0, rv4)); Assert.assertEquals(g1c4.subSeq(rv4), g2.subSeq(rv4)); }); });
@Test(dataProvider = "subSequences") public void subSubSeqImmutable(final Named<MSeq<Integer>> parameter) { final MSeq<Integer> seq = parameter.value; final Integer second = seq.get(1); final Integer third = seq.get(2); final Integer fourth = seq.get(3); final MSeq<Integer> slice = seq.subSeq(1); Assert.assertEquals(slice.get(0), second); final MSeq<Integer> sliceSlice = slice.subSeq(1); Assert.assertEquals(sliceSlice.get(0), third); final ISeq<Integer> islice = slice.toISeq(); Assert.assertEquals(islice.get(0), second); final ISeq<Integer> isliceSlice = sliceSlice.toISeq(); final ISeq<Integer> isliceSlice2 = islice.subSeq(1); Assert.assertEquals(isliceSlice.get(0), third); Assert.assertEquals(isliceSlice2.get(0), third); final Integer newSecond = -22; seq.set(1, newSecond); Assert.assertEquals(slice.get(0), newSecond); Assert.assertEquals(islice.get(0), second); final Integer newThird = -333; seq.set(2, newThird); Assert.assertEquals(sliceSlice.get(0), newThird); Assert.assertEquals(isliceSlice.get(0), third); Assert.assertEquals(isliceSlice2.get(0), third); final Integer newFourth = -4444; seq.set(3, newFourth); Assert.assertEquals(sliceSlice.get(1), newFourth); Assert.assertEquals(isliceSlice2.subSeq(1).get(0), fourth); }
@Test(dataProvider = "subSequences") public void subSubSeqImmutable2(final Named<MSeq<Integer>> parameter) { final MSeq<Integer> seq = parameter.value; final Integer[] values = seq.toArray(new Integer[seq.length()]); final Integer[] newValues = seq .map(i -> -i) .toArray(new Integer[seq.length()]); final Integer[] newValues2 = seq .map(i -> -i - 1000) .toArray(new Integer[seq.length()]); ISeq<Integer> iseq = seq.toISeq(); MSeq<Integer> mseq = seq; for (int i = 0; i < seq.length(); ++i) { Assert.assertEquals(seq.get(i), values[i]); Assert.assertEquals(mseq.get(0), values[i]); Assert.assertEquals(iseq.get(0), values[i]); seq.set(i, newValues[i]); Assert.assertEquals(seq.get(i), newValues[i]); Assert.assertEquals(mseq.get(0), newValues[i]); Assert.assertEquals(iseq.get(0), values[i]); mseq.set(0, newValues2[i]); Assert.assertEquals(seq.get(i), newValues2[i]); Assert.assertEquals(mseq.get(0), newValues2[i]); Assert.assertEquals(iseq.get(0), values[i]); iseq = iseq.subSeq(1); mseq = mseq.subSeq(1); } }