@Test
public void drop() {
Assert.assertEquals(FastList.newListWith(3, 4), Interval.fromTo(1, 4).drop(2));
Verify.assertIterableEmpty(Interval.fromTo(1, 2).drop(3));
Verify.assertThrows(IllegalArgumentException.class, () -> Interval.fromTo(1, 3).drop(-1));
}
@Test
public void take() {
Assert.assertEquals(FastList.newListWith(1, 2), Interval.fromTo(1, 3).take(2));
Assert.assertEquals(FastList.newListWith(1, 2), Interval.fromTo(1, 2).take(3));
Verify.assertThrows(IllegalArgumentException.class, () -> Interval.fromTo(1, 3).take(-1));
}
@Test
public void lastIndexOf() {
Interval interval = Interval.fromTo(-10, 12).by(5);
Assert.assertEquals(0, interval.lastIndexOf(-10));
Assert.assertEquals(1, interval.lastIndexOf(-5));
Assert.assertEquals(2, interval.lastIndexOf(0));
Assert.assertEquals(3, interval.lastIndexOf(5));
Assert.assertEquals(4, interval.lastIndexOf(10));
Assert.assertEquals(-1, interval.lastIndexOf(-15));
Assert.assertEquals(-1, interval.lastIndexOf(-11));
Assert.assertEquals(-1, interval.lastIndexOf(-9));
Assert.assertEquals(-1, interval.lastIndexOf(11));
Assert.assertEquals(-1, interval.lastIndexOf(15));
Assert.assertEquals(-1, interval.lastIndexOf(new Object()));
Interval backwardsInterval = Interval.fromTo(10, -12).by(-5);
Assert.assertEquals(0, backwardsInterval.lastIndexOf(10));
Assert.assertEquals(1, backwardsInterval.lastIndexOf(5));
Assert.assertEquals(2, backwardsInterval.lastIndexOf(0));
Assert.assertEquals(3, backwardsInterval.lastIndexOf(-5));
Assert.assertEquals(4, backwardsInterval.lastIndexOf(-10));
Assert.assertEquals(-1, backwardsInterval.lastIndexOf(15));
Assert.assertEquals(-1, backwardsInterval.lastIndexOf(11));
Assert.assertEquals(-1, backwardsInterval.lastIndexOf(9));
Assert.assertEquals(-1, backwardsInterval.lastIndexOf(-11));
Assert.assertEquals(-1, backwardsInterval.lastIndexOf(-15));
}
@Test
public void getLast() {
Assert.assertEquals(Integer.valueOf(-10), Interval.fromTo(10, -10).by(-5).getLast());
Assert.assertEquals(Integer.valueOf(-10), Interval.fromTo(10, -12).by(-5).getLast());
Assert.assertEquals(Integer.valueOf(10), Interval.fromTo(-10, 10).by(5).getLast());
Assert.assertEquals(Integer.valueOf(10), Interval.fromTo(-10, 12).by(5).getLast());
Assert.assertEquals(Integer.valueOf(0), Interval.zero().getLast());
}
@Test
public void fromAndToAndBy() {
Interval interval = Interval.from(1);
Interval interval2 = interval.to(10);
Interval interval3 = interval2.by(2);
Verify.assertEqualsAndHashCode(interval, Interval.fromTo(1, 1));
Verify.assertEqualsAndHashCode(interval2, Interval.fromTo(1, 10));
Verify.assertEqualsAndHashCode(interval3, Interval.fromToBy(1, 10, 2));
}
@Test
public void product() {
Assert.assertEquals(0, Interval.zero().product().intValue());
Assert.assertEquals(0, Interval.fromTo(-1, 1).product().intValue());
Assert.assertEquals(2, Interval.fromTo(-2, -1).product().intValue());
Assert.assertEquals(-6, Interval.fromTo(-3, -1).product().intValue());
Assert.assertEquals(200, Interval.fromToBy(10, 20, 10).product().intValue());
Assert.assertEquals(200, Interval.fromToBy(-10, -20, -10).product().intValue());
Assert.assertEquals(-6000, Interval.fromToBy(-10, -30, -10).product().intValue());
Assert.assertEquals(6000, Interval.fromToBy(30, 10, -10).product().intValue());
Assert.assertEquals(6000, Interval.fromToBy(30, 10, -10).reverseThis().product().intValue());
}
@Test
public void iterator() {
Interval zero = Interval.zero();
Iterator<Integer> zeroIterator = zero.iterator();
Assert.assertTrue(zeroIterator.hasNext());
Assert.assertEquals(Integer.valueOf(0), zeroIterator.next());
Assert.assertFalse(zeroIterator.hasNext());
Interval oneToFive = Interval.oneTo(5);
Iterator<Integer> oneToFiveIterator = oneToFive.iterator();
for (int i = 1; i < 6; i++) {
Assert.assertTrue(oneToFiveIterator.hasNext());
Assert.assertEquals(Integer.valueOf(i), oneToFiveIterator.next());
}
Verify.assertThrows(NoSuchElementException.class, (Runnable) oneToFiveIterator::next);
Interval threeToNegativeThree = Interval.fromTo(3, -3);
Iterator<Integer> threeToNegativeThreeIterator = threeToNegativeThree.iterator();
for (int i = 3; i > -4; i--) {
Assert.assertTrue(threeToNegativeThreeIterator.hasNext());
Assert.assertEquals(Integer.valueOf(i), threeToNegativeThreeIterator.next());
}
Verify.assertThrows(
NoSuchElementException.class, (Runnable) threeToNegativeThreeIterator::next);
Verify.assertThrows(
UnsupportedOperationException.class, () -> Interval.zeroTo(10).iterator().remove());
}
@Test
public void contains() {
Assert.assertTrue(Interval.zero().contains(0));
Assert.assertTrue(Interval.oneTo(5).containsAll(1, 5));
Assert.assertTrue(Interval.oneTo(5).containsNone(6, 7));
Assert.assertFalse(Interval.oneTo(5).containsAll(1, 6));
Assert.assertFalse(Interval.oneTo(5).containsNone(1, 6));
Assert.assertFalse(Interval.oneTo(5).contains(0));
Assert.assertTrue(Interval.fromTo(-1, -5).containsAll(-1, -5));
Assert.assertFalse(Interval.fromTo(-1, -5).contains(1));
Assert.assertTrue(Interval.zero().contains(Integer.valueOf(0)));
Assert.assertFalse(Interval.oneTo(5).contains(Integer.valueOf(0)));
Assert.assertFalse(Interval.fromTo(-1, -5).contains(Integer.valueOf(1)));
Assert.assertFalse(Interval.zeroTo(5).contains(new Object()));
}
@Test
public void tap() {
MutableList<Integer> tapResult = Lists.mutable.of();
Interval interval = Interval.fromTo(10, -10).by(-5);
LazyIterable<Integer> lazyTapIterable = interval.tap(tapResult::add);
lazyTapIterable.each(x -> {}); // force evaluation
Assert.assertEquals(interval, tapResult);
}
@Test
public void reject() {
Interval interval = Interval.fromTo(10, -10).by(-5);
MutableList<Integer> expected = FastList.newListWith(5, -5);
Assert.assertEquals(
expected, interval.reject(IntegerPredicates.isEven(), FastList.<Integer>newList()));
}
@Test
public void collect() {
Interval interval = Interval.fromTo(10, -10).by(-5);
MutableList<String> expected = FastList.newListWith("10", "5", "0", "-5", "-10");
Assert.assertEquals(expected, interval.collect(String::valueOf).toList());
Assert.assertEquals(expected, interval.collect(String::valueOf, FastList.<String>newList()));
}
@Test
public void run() {
IntegerSum sum = new IntegerSum(0);
Interval.oneTo(5).run(() -> sum.add(1));
Assert.assertEquals(5, sum.getIntSum());
IntegerSum sum2 = new IntegerSum(0);
Interval.fromTo(5, 1).run(() -> sum2.add(1));
Assert.assertEquals(5, sum2.getIntSum());
}
@Test
public void size() {
Assert.assertEquals(100, Interval.fromTo(1, 100).size());
Assert.assertEquals(50, Interval.fromToBy(1, 100, 2).size());
Assert.assertEquals(34, Interval.fromToBy(1, 100, 3).size());
Assert.assertEquals(25, Interval.fromToBy(1, 100, 4).size());
Assert.assertEquals(20, Interval.fromToBy(1, 100, 5).size());
Assert.assertEquals(17, Interval.fromToBy(1, 100, 6).size());
Assert.assertEquals(15, Interval.fromToBy(1, 100, 7).size());
Assert.assertEquals(13, Interval.fromToBy(1, 100, 8).size());
Assert.assertEquals(12, Interval.fromToBy(1, 100, 9).size());
Assert.assertEquals(10, Interval.fromToBy(1, 100, 10).size());
Assert.assertEquals(11, Interval.fromTo(0, 10).size());
Assert.assertEquals(1, Interval.zero().size());
Assert.assertEquals(11, Interval.fromTo(0, -10).size());
Assert.assertEquals(3, Interval.evensFromTo(2, -2).size());
Assert.assertEquals(2, Interval.oddsFromTo(2, -2).size());
}
@Test
public void runWithExecutorInReverse() throws InterruptedException {
MutableList<String> result = Lists.mutable.of();
ExecutorService service = Executors.newSingleThreadExecutor();
Interval.fromTo(3, 1).run(() -> result.add(null), service);
service.shutdown();
service.awaitTermination(20, TimeUnit.SECONDS);
Assert.assertEquals(FastList.<String>newListWith(null, null, null), result);
}
@Test
public void forEachWith() {
IntegerSum sum = new IntegerSum(0);
Interval.oneTo(5)
.forEachWith((Integer each, Integer parameter) -> sum.add(each + parameter), 0);
Assert.assertEquals(15, sum.getIntSum());
IntegerSum sum2 = new IntegerSum(0);
Interval.fromTo(5, 1)
.forEachWith((Integer each, Integer parameter) -> sum2.add(each + parameter), 0);
Assert.assertEquals(15, sum2.getIntSum());
}
@Test
public void get() {
Interval interval = Interval.fromTo(-10, 12).by(5);
Assert.assertEquals(Integer.valueOf(-10), interval.get(0));
Assert.assertEquals(Integer.valueOf(-5), interval.get(1));
Assert.assertEquals(Integer.valueOf(0), interval.get(2));
Assert.assertEquals(Integer.valueOf(5), interval.get(3));
Assert.assertEquals(Integer.valueOf(10), interval.get(4));
Verify.assertThrows(IndexOutOfBoundsException.class, () -> interval.get(-1));
Verify.assertThrows(IndexOutOfBoundsException.class, () -> interval.get(5));
}
@Test
public void factorial() {
Verify.assertThrows(IllegalStateException.class, () -> Interval.fromTo(-1, -5).factorial());
Assert.assertEquals(1, Interval.zero().factorial().intValue());
Assert.assertEquals(1, Interval.oneTo(1).factorial().intValue());
Assert.assertEquals(6, Interval.oneTo(3).factorial().intValue());
Assert.assertEquals(2432902008176640000L, Interval.oneTo(20).factorial().longValue());
Assert.assertEquals(new BigInteger("51090942171709440000"), Interval.oneTo(21).factorial());
Assert.assertEquals(
new BigInteger("1405006117752879898543142606244511569936384000000000"),
Interval.oneTo(42).factorial());
}
@Test
public void forEachWith_with_start_end() {
Interval interval = Interval.fromTo(-10, 12).by(5);
MutableList<Integer> forwardResult = Lists.mutable.of();
interval.forEachWithIndex(new AddParametersProcedure(forwardResult), 1, 3);
Assert.assertEquals(FastList.newListWith(-4, 2, 8), forwardResult);
MutableList<Integer> backwardsResult = Lists.mutable.of();
interval.forEachWithIndex(new AddParametersProcedure(backwardsResult), 3, 1);
Assert.assertEquals(FastList.newListWith(8, 2, -4), backwardsResult);
}
@Test
public void forEachWithIndex() {
IntegerSum sum = new IntegerSum(0);
Interval.oneTo(5)
.forEachWithIndex((ObjectIntProcedure<Integer>) (each, index) -> sum.add(each + index));
Assert.assertEquals(25, sum.getIntSum());
IntegerSum zeroSum = new IntegerSum(0);
Interval.fromTo(0, -4)
.forEachWithIndex((ObjectIntProcedure<Integer>) (each, index) -> zeroSum.add(each + index));
Assert.assertEquals(0, zeroSum.getIntSum());
Verify.assertThrows(
IndexOutOfBoundsException.class, () -> Interval.zeroTo(10).forEachWithIndex(null, -1, 10));
}
@Test
public void forEach_with_start_end() {
Interval interval = Interval.fromTo(-10, 12).by(5);
MutableList<Integer> forwardResult = Lists.mutable.of();
interval.forEach(CollectionAddProcedure.on(forwardResult), 1, 3);
Assert.assertEquals(FastList.newListWith(-5, 0, 5), forwardResult);
MutableList<Integer> backwardsResult = Lists.mutable.of();
interval.forEach(CollectionAddProcedure.on(backwardsResult), 3, 1);
Assert.assertEquals(FastList.newListWith(5, 0, -5), backwardsResult);
Verify.assertThrows(IndexOutOfBoundsException.class, () -> interval.forEach(null, -1, 3));
}
@Test
public void equalsAndHashCode() {
Interval interval1 = Interval.oneTo(5);
Interval interval2 = Interval.oneTo(5);
Interval interval3 = Interval.zeroTo(5);
Verify.assertPostSerializedEqualsAndHashCode(interval1);
Verify.assertEqualsAndHashCode(interval1, interval2);
Assert.assertNotEquals(interval1, interval3);
Assert.assertNotEquals(interval3, interval1);
Verify.assertEqualsAndHashCode(Interval.fromToBy(1, 5, 2), Interval.fromToBy(1, 6, 2));
Verify.assertEqualsAndHashCode(FastList.newListWith(1, 2, 3), Interval.fromTo(1, 3));
Verify.assertEqualsAndHashCode(FastList.newListWith(3, 2, 1), Interval.fromTo(3, 1));
Assert.assertNotEquals(FastList.newListWith(1, 2, 3, 4), Interval.fromTo(1, 3));
Assert.assertNotEquals(FastList.newListWith(1, 2, 4), Interval.fromTo(1, 3));
Assert.assertNotEquals(FastList.newListWith(3, 2, 0), Interval.fromTo(3, 1));
Verify.assertEqualsAndHashCode(FastList.newListWith(-1, -2, -3), Interval.fromTo(-1, -3));
}
@Test(expected = UnsupportedOperationException.class)
public void add_at_index() {
Interval.fromTo(1, 3).add(0, 4);
}
@Test(expected = UnsupportedOperationException.class)
public void set() {
Interval.fromTo(1, 3).set(0, 0);
}
@Test(expected = UnsupportedOperationException.class)
public void clear() {
Interval.fromTo(1, 3).clear();
}
@Test(expected = UnsupportedOperationException.class)
public void retainAll() {
Interval.fromTo(1, 3).retainAll(FastList.newListWith(4, 5, 6));
}
@Test(expected = UnsupportedOperationException.class)
public void addAll_at_index() {
Interval.fromTo(1, 3).addAll(0, FastList.newListWith(4, 5, 6));
}
@Test(expected = UnsupportedOperationException.class)
public void remove_at_index() {
Interval.fromTo(1, 3).remove(0);
}
@Test(expected = UnsupportedOperationException.class)
public void remove() {
Interval.fromTo(1, 3).remove(Integer.valueOf(4));
}
@Test
public void containsAll() {
Assert.assertTrue(Interval.fromTo(1, 3).containsAll(FastList.newListWith(1, 2, 3)));
Assert.assertFalse(Interval.fromTo(1, 3).containsAll(FastList.newListWith(1, 2, 4)));
}
@Test
public void subList() {
Interval interval = Interval.fromTo(1, 5);
Assert.assertEquals(FastList.newListWith(2, 3), interval.subList(1, 3));
}
