diff --git a/cyclops-futurestream/src/test/java/cyclops/futurestream/react/lazy/sequence/WindowingTest.java b/cyclops-futurestream/src/test/java/cyclops/futurestream/react/lazy/sequence/WindowingTest.java index 29a97b89cd..d9e039c6b3 100644 --- a/cyclops-futurestream/src/test/java/cyclops/futurestream/react/lazy/sequence/WindowingTest.java +++ b/cyclops-futurestream/src/test/java/cyclops/futurestream/react/lazy/sequence/WindowingTest.java @@ -143,12 +143,12 @@ public void groupedOnEmpty() throws Exception { assertThat( empty.grouped(10).count(),equalTo(0l)); } - @Test(expected=IllegalArgumentException.class) + @Test public void groupedEmpty0() throws Exception { empty.grouped(0).toList(); } - @Test(expected=IllegalArgumentException.class) + @Test public void grouped0() throws Exception { nonEmpty.grouped(0).toList(); diff --git a/cyclops-reactor-integration/src/test/java/cyclops/streams/asyncreactivestreams/AsyncRSReactiveStreamXTest.java b/cyclops-reactor-integration/src/test/java/cyclops/streams/asyncreactivestreams/AsyncRSReactiveStreamXTest.java index 0667da395a..05d32b3b43 100644 --- a/cyclops-reactor-integration/src/test/java/cyclops/streams/asyncreactivestreams/AsyncRSReactiveStreamXTest.java +++ b/cyclops-reactor-integration/src/test/java/cyclops/streams/asyncreactivestreams/AsyncRSReactiveStreamXTest.java @@ -193,7 +193,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { diff --git a/cyclops-reactor-integration/src/test/java/cyclops/streams/syncflux/SyncReactiveStreamXTest.java b/cyclops-reactor-integration/src/test/java/cyclops/streams/syncflux/SyncReactiveStreamXTest.java index 72253d0ed7..24c412fc15 100644 --- a/cyclops-reactor-integration/src/test/java/cyclops/streams/syncflux/SyncReactiveStreamXTest.java +++ b/cyclops-reactor-integration/src/test/java/cyclops/streams/syncflux/SyncReactiveStreamXTest.java @@ -187,7 +187,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { diff --git a/cyclops-rxjava2-integration/src/test/java/cyclops/streams/flowables/asyncreactivestreams/AsyncRSReactiveStreamXTest.java b/cyclops-rxjava2-integration/src/test/java/cyclops/streams/flowables/asyncreactivestreams/AsyncRSReactiveStreamXTest.java index 07ded2fa6e..bed2fa7460 100644 --- a/cyclops-rxjava2-integration/src/test/java/cyclops/streams/flowables/asyncreactivestreams/AsyncRSReactiveStreamXTest.java +++ b/cyclops-rxjava2-integration/src/test/java/cyclops/streams/flowables/asyncreactivestreams/AsyncRSReactiveStreamXTest.java @@ -213,7 +213,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { diff --git a/cyclops-rxjava2-integration/src/test/java/cyclops/streams/flowables/syncflux/SyncReactiveStreamXTest.java b/cyclops-rxjava2-integration/src/test/java/cyclops/streams/flowables/syncflux/SyncReactiveStreamXTest.java index fd7dbcdd1c..89145cceb5 100644 --- a/cyclops-rxjava2-integration/src/test/java/cyclops/streams/flowables/syncflux/SyncReactiveStreamXTest.java +++ b/cyclops-rxjava2-integration/src/test/java/cyclops/streams/flowables/syncflux/SyncReactiveStreamXTest.java @@ -187,7 +187,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { diff --git a/cyclops-rxjava2-integration/src/test/java/cyclops/streams/observables/AsyncReactiveStreamXTest.java b/cyclops-rxjava2-integration/src/test/java/cyclops/streams/observables/AsyncReactiveStreamXTest.java index 8ceca09531..b3234cdbd9 100644 --- a/cyclops-rxjava2-integration/src/test/java/cyclops/streams/observables/AsyncReactiveStreamXTest.java +++ b/cyclops-rxjava2-integration/src/test/java/cyclops/streams/observables/AsyncReactiveStreamXTest.java @@ -194,7 +194,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/ReactiveStreamX.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/ReactiveStreamX.java index b3d40f9032..2fcce75a83 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/ReactiveStreamX.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/ReactiveStreamX.java @@ -296,24 +296,24 @@ public ReactiveSeq> grouped(final int groupSize) { @Override public ReactiveSeq> groupedWhile(final BiPredicate, ? super T> predicate) { - return createSeq(new GroupedStatefullyOperator<>(source, () -> Vector.empty(), Function.identity(), predicate)); + return createSeq(new GroupedStatefullyOperator<>(source, () -> Vector.empty(), Function.identity(), predicate.negate())); } @Override public , R> ReactiveSeq groupedWhile(final BiPredicate predicate, final Supplier factory, Function finalizer) { - return this.createSeq(new GroupedStatefullyOperator<>(source, factory, finalizer, predicate)); + return this.createSeq(new GroupedStatefullyOperator<>(source, factory, finalizer, predicate.negate())); } @Override public ReactiveSeq> groupedUntil(final BiPredicate, ? super T> predicate) { - return createSeq(new GroupedStatefullyOperator<>(source, () -> Vector.empty(), Function.identity(), predicate.negate())); + return createSeq(new GroupedStatefullyOperator<>(source, () -> Vector.empty(), Function.identity(), predicate)); } @Override public , R> ReactiveSeq groupedUntil(final BiPredicate predicate, final Supplier factory, Function finalizer) { - return this.createSeq(new GroupedStatefullyOperator<>(source, factory, finalizer, predicate.negate())); + return this.createSeq(new GroupedStatefullyOperator<>(source, factory, finalizer, predicate)); } @Override @@ -722,11 +722,11 @@ public ReactiveSeq appendAll(final T... other) { @Override public ReactiveSeq prependStream(final Stream other) { - return Spouts.concat((Stream) (other), this); + return Spouts.concat(other, this); } public ReactiveSeq prependAll(final Iterable other) { - return Spouts.concat((Stream) (other), this); + return Spouts.concat((Spouts.fromIterable( other)), this); } @Override @@ -832,7 +832,8 @@ public > ReactiveSeq grouped(final @Override public ReactiveSeq dropRight(final int num) { - + if(num<=0) + return this; if(num==1) return createSeq(new SkipLastOneOperator<>(source)); return createSeq(new SkipLastOperator<>(source, num < 0 ? 0 : num)); @@ -840,6 +841,8 @@ public ReactiveSeq dropRight(final int num) { @Override public ReactiveSeq takeRight(final int num) { + if(num<=0) + return Spouts.empty(); if (num == 1) return createSeq(new LimitLastOneOperator<>(source)); return createSeq(new LimitLastOperator<>(source, num < 0 ? 0 : num)); @@ -1481,5 +1484,19 @@ public void onComplete() { return maybe; } + @Override + public int hashCode() { + return vector().hashCode(); + } + + @Override + public boolean equals(Object obj) { + if(obj instanceof ReactiveSeq){ + ReactiveSeq it = (ReactiveSeq) obj; + return this.equalToIteration(it); + + } + return super.equals(obj); + } } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/SpliteratorBasedStream.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/SpliteratorBasedStream.java index 292e9649dd..740d49941f 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/SpliteratorBasedStream.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/SpliteratorBasedStream.java @@ -222,10 +222,6 @@ public final ReactiveSeq scanLeft(final U seed, final BiFunction skip(final long num) { - if(this.stream instanceof Indexable){ - Indexable indexable = (Indexable)stream; - return createSeq(indexable.skip(num),reversible); - } return createSeq(new SkipSpliterator<>(get(),num), reversible); } @@ -246,13 +242,6 @@ public final ReactiveSeq dropUntil(final Predicate p) { @Override public ReactiveSeq limit(final long num) { - - if(this.stream instanceof Indexable){ - Indexable indexable = (Indexable)stream; - Spliterator limit = indexable.take(num); - - return createSeq(limit,Optional.empty()); - } return createSeq(new LimitSpliterator(get(),num), reversible); } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/StreamX.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/StreamX.java index 271d090fea..0212911418 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/StreamX.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/StreamX.java @@ -174,4 +174,18 @@ public R fold(Function,? extends R> sync, Function,R> private final int groupSize; public GroupingSpliterator(final Spliterator source, Supplier factory, Function finalizer,int groupSize) { super(source.estimateSize(),source.characteristics() & Spliterator.ORDERED); - if(groupSize<=0) - throw new IllegalArgumentException("Group size must be greater than "); + this.source = source; this.factory = factory; - this.groupSize = groupSize; + this.groupSize = groupSize >0 ? groupSize : 1; this.finalizer=finalizer; collection =factory.get(); @@ -66,7 +65,7 @@ public void forEachRemaining(Consumer action) { public boolean tryAdvance(Consumer action) { if(closed) return false; - for(int i=collection.size();i { collection = (C)collection.plus(t); diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/Indexable.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/Indexable.java deleted file mode 100644 index 8d5fbfec1a..0000000000 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/Indexable.java +++ /dev/null @@ -1,13 +0,0 @@ -package com.oath.cyclops.internal.stream.spliterators; - -import java.util.Spliterator; - -/** - * Created by johnmcclean on 05/01/2017. - */ -public interface Indexable { - - Spliterator skip(long start); - Spliterator take(long end); - -} diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/LimitLastSpliterator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/LimitLastSpliterator.java index b3a1d20d16..120f06a172 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/LimitLastSpliterator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/LimitLastSpliterator.java @@ -1,6 +1,8 @@ package com.oath.cyclops.internal.stream.spliterators; import java.util.ArrayDeque; +import java.util.Deque; +import java.util.LinkedList; import java.util.Spliterator; import java.util.Spliterators; import java.util.Spliterators.AbstractSpliterator; @@ -22,14 +24,14 @@ public static Spliterator takeRight(Spliterator source, int limit){ } - private final ArrayDeque buffer; + private final Deque buffer; private final int limit; private final Spliterator source; public LimitLastSpliterator(final Spliterator source, final int limit) { super(source.estimateSize(),source.characteristics() & Spliterator.ORDERED); - buffer = new ArrayDeque<>( - limit); + buffer = limit < 1_000 ? new ArrayDeque<>( + limit) : new LinkedList<>(); this.source = source;; this.limit = limit; } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ReversingArraySpliterator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ReversingArraySpliterator.java index 332095586f..841c4a697c 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ReversingArraySpliterator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ReversingArraySpliterator.java @@ -7,8 +7,8 @@ import lombok.Getter; import lombok.Setter; -//@AllArgsConstructor -public class ReversingArraySpliterator implements Spliterator, ReversableSpliterator, Indexable { + +public class ReversingArraySpliterator implements Spliterator, ReversableSpliterator { private final Object[] array; private int max; @@ -106,21 +106,5 @@ public ReversableSpliterator copy() { array, start,max,reverse); } - @Override - public Spliterator skip(long offset) { - this.start = index= this.start+(int)offset; - return new ReversingArraySpliterator( - array, start, max,reverse); - - - } - - @Override - public Spliterator take(long num) { - this.max = start+(int)num; - return new ReversingArraySpliterator( - array, start, max,reverse); - } - } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/SkipLastSpliterator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/SkipLastSpliterator.java index cd9e99beb0..1b5aa19946 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/SkipLastSpliterator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/SkipLastSpliterator.java @@ -1,6 +1,8 @@ package com.oath.cyclops.internal.stream.spliterators; import java.util.ArrayDeque; +import java.util.Deque; +import java.util.LinkedList; import java.util.Spliterator; import java.util.Spliterators; import java.util.Spliterators.AbstractSpliterator; @@ -21,14 +23,14 @@ public static Spliterator dropRight(Spliterator source, int skip){ } - private final ArrayDeque buffer; + private final Deque buffer; private final int skip; private final Spliterator source; public SkipLastSpliterator(final Spliterator source, final int skip) { super(source.estimateSize(),source.characteristics() & Spliterator.ORDERED); - buffer = new ArrayDeque<>( - skip); + buffer = skip <1_000 ? new ArrayDeque<>( + skip) : new LinkedList<>(); this.source = source;; this.skip = skip; } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/doubles/ReversingDoubleArraySpliterator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/doubles/ReversingDoubleArraySpliterator.java index 2ffe15eb95..efd500de5b 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/doubles/ReversingDoubleArraySpliterator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/doubles/ReversingDoubleArraySpliterator.java @@ -1,6 +1,6 @@ package com.oath.cyclops.internal.stream.spliterators.doubles; -import com.oath.cyclops.internal.stream.spliterators.Indexable; + import com.oath.cyclops.internal.stream.spliterators.ReversableSpliterator; import lombok.Getter; import lombok.Setter; @@ -11,7 +11,7 @@ import java.util.function.DoubleConsumer; //@AllArgsConstructor -public class ReversingDoubleArraySpliterator implements Spliterator.OfDouble,ReversableSpliterator, Indexable { +public class ReversingDoubleArraySpliterator implements Spliterator.OfDouble,ReversableSpliterator { private final double[] array; private int max; @@ -152,16 +152,5 @@ public ReversableSpliterator copy() { array, start,max,reverse); } - @Override - public Spliterator skip(long offset) { - this.start = index= this.start+(int)offset; - return this; - } - - @Override - public Spliterator take(long num) { - this.max = start+(int)num; - return this; - } } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ints/ReversingIntArraySpliterator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ints/ReversingIntArraySpliterator.java index 5ad378c1d3..6ca35c34ee 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ints/ReversingIntArraySpliterator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ints/ReversingIntArraySpliterator.java @@ -1,6 +1,6 @@ package com.oath.cyclops.internal.stream.spliterators.ints; -import com.oath.cyclops.internal.stream.spliterators.Indexable; + import com.oath.cyclops.internal.stream.spliterators.ReversableSpliterator; import lombok.Getter; import lombok.Setter; @@ -11,7 +11,7 @@ import java.util.function.IntConsumer; //@AllArgsConstructor -public class ReversingIntArraySpliterator implements Spliterator.OfInt,ReversableSpliterator, Indexable { +public class ReversingIntArraySpliterator implements Spliterator.OfInt,ReversableSpliterator { private final int[] array; private int max; @@ -152,16 +152,6 @@ public ReversableSpliterator copy() { array, start,max,reverse); } - @Override - public Spliterator skip(long offset) { - this.start = index= this.start+(int)offset; - return this; - } - @Override - public Spliterator take(long num) { - this.max = start+(int)num; - return this; - } } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ints/ReversingRangeIntSpliterator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ints/ReversingRangeIntSpliterator.java index f8a050ebfb..2ddbe95397 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ints/ReversingRangeIntSpliterator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/ints/ReversingRangeIntSpliterator.java @@ -5,19 +5,19 @@ import java.util.function.Consumer; import java.util.function.IntConsumer; -import com.oath.cyclops.internal.stream.spliterators.Indexable; import com.oath.cyclops.internal.stream.spliterators.ReversableSpliterator; import lombok.Getter; import lombok.Setter; -public class ReversingRangeIntSpliterator implements Spliterator.OfInt, ReversableSpliterator, Indexable { +public class ReversingRangeIntSpliterator implements Spliterator.OfInt, ReversableSpliterator { private final int min; private final int max; private int index; - private int start; + private int start; private int step; + @Getter @Setter private boolean reverse; @@ -25,13 +25,28 @@ public class ReversingRangeIntSpliterator implements Spliterator.OfInt, Reversab public ReversingRangeIntSpliterator(final int min, final int max, final int step, final boolean reverse) { this.min = min; this.max = max; - // this.reverse = this.max >= this.min ? reverse : !reverse; this.reverse = reverse; this.step =step; - if(!reverse) - start =index = min; - else - start = index=max; + if(!reverse) { + start = index = min; + } + else { + start = index = max - 1; + } + } + ReversingRangeIntSpliterator(final int min, final int max, final int step, final boolean reverse,int start) { + this.min = min; + this.max = max; + this.reverse = reverse; + this.step =step; + this.start = start; + if(!reverse) { + index = start; + } + else { + index = start; + } + } @Override @@ -51,7 +66,7 @@ public boolean tryAdvance(final IntConsumer consumer) { } } if (reverse) { - if (index > min && index <= max) { + if (index >= min && index <= max) { consumer.accept(index); index = index-step; return true; @@ -78,12 +93,10 @@ public Spliterator.OfInt trySplit() { @Override public ReversableSpliterator copy() { return new ReversingRangeIntSpliterator( - min, max, step,reverse); + min, max, step,reverse,start); } - /* (non-Javadoc) - * @see java.util.Spliterator.OfInt#forEachRemaining(java.util.function.IntConsumer) - */ + @Override public void forEachRemaining(IntConsumer action) { int index = this.index; //use local index making spliterator reusable @@ -95,7 +108,7 @@ public void forEachRemaining(IntConsumer action) { } } if (reverse) { - for( ;index > min && index <= max;) { + for( ;index >= min && index <= max;) { action.accept(index); index = index-step; @@ -104,9 +117,7 @@ public void forEachRemaining(IntConsumer action) { } } - /* (non-Javadoc) - * @see java.util.Spliterator.OfInt#forEachRemaining(java.util.function.Consumer) - */ + @Override public void forEachRemaining(Consumer action) { int index = this.index; //use local index making spliterator reusable @@ -117,7 +128,7 @@ public void forEachRemaining(Consumer action) { } } if (reverse) { - for( ;index > min && index <= max;) { + for( ;index >= min && index <= max;) { action.accept(index); index = index-step; } @@ -125,35 +136,6 @@ public void forEachRemaining(Consumer action) { } } - @Override - public Spliterator skip(long offset) { - if(reverse){ - return new ReversingRangeIntSpliterator( - min, max-(int)offset,step, reverse); - - }else{ - return new ReversingRangeIntSpliterator( - start+(int)offset, max, step,reverse); - } - - - } - - @Override - public Spliterator take(long number) { - if(reverse){ - return new ReversingRangeIntSpliterator( - max-(int)number, max, step,reverse); - - } - else{ - return new ReversingRangeIntSpliterator( - min, start+(int)number, step, reverse); - - } - - - } } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/longs/ReversingLongArraySpliterator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/longs/ReversingLongArraySpliterator.java index aeda8423da..bb22152c1d 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/longs/ReversingLongArraySpliterator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/longs/ReversingLongArraySpliterator.java @@ -1,6 +1,5 @@ package com.oath.cyclops.internal.stream.spliterators.longs; -import com.oath.cyclops.internal.stream.spliterators.Indexable; import com.oath.cyclops.internal.stream.spliterators.ReversableSpliterator; import lombok.Getter; import lombok.Setter; @@ -11,7 +10,7 @@ import java.util.function.LongConsumer; //@AllArgsConstructor -public class ReversingLongArraySpliterator implements Spliterator.OfLong,ReversableSpliterator, Indexable { +public class ReversingLongArraySpliterator implements Spliterator.OfLong,ReversableSpliterator { private final long[] array; private int max; @@ -151,16 +150,6 @@ public ReversableSpliterator copy() { array, start,max,reverse); } - @Override - public Spliterator skip(long offset) { - this.start = index= this.start+(int)offset; - return this; - } - @Override - public Spliterator take(long num) { - this.max = start+(int)num; - return this; - } } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/longs/ReversingRangeLongSpliterator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/longs/ReversingRangeLongSpliterator.java index 47337829ba..57570aab5d 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/longs/ReversingRangeLongSpliterator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/longs/ReversingRangeLongSpliterator.java @@ -1,41 +1,57 @@ package com.oath.cyclops.internal.stream.spliterators.longs; -import com.oath.cyclops.internal.stream.spliterators.Indexable; -import com.oath.cyclops.internal.stream.spliterators.ReversableSpliterator; -import lombok.Getter; -import lombok.Setter; - import java.util.Objects; import java.util.Spliterator; import java.util.function.Consumer; +import java.util.function.IntConsumer; import java.util.function.LongConsumer; -public class ReversingRangeLongSpliterator implements Spliterator.OfLong, ReversableSpliterator, Indexable { +import com.oath.cyclops.internal.stream.spliterators.ReversableSpliterator; +import lombok.Getter; +import lombok.Setter; + +public class ReversingRangeLongSpliterator implements Spliterator.OfLong,ReversableSpliterator { private final long min; private final long max; private long index; private long start; - private final long step; + private long step; + @Getter @Setter private boolean reverse; - public ReversingRangeLongSpliterator(final long min, final long max, final long step,final boolean reverse) { + public ReversingRangeLongSpliterator(final long min, final long max, final long step, final boolean reverse) { this.min = min; this.max = max; - this.step = step; - this.reverse = reverse; - if(!reverse) - start =index = min; - else - start = index=max; + this.step =step; + if(!reverse) { + start = index = min; + } + else { + start = index = max - 1; + } + } + ReversingRangeLongSpliterator(final long min, final long max, final long step, final boolean reverse,long start) { + this.min = min; + this.max = max; + this.reverse = reverse; + this.step =step; + this.start = start; + if(!reverse) { + index = start; + } + else { + index = start; + } + } @Override - public ReversableSpliterator invert() { + public ReversingRangeLongSpliterator invert() { return new ReversingRangeLongSpliterator(min,max,step,!reverse); } @@ -51,7 +67,7 @@ public boolean tryAdvance(final LongConsumer consumer) { } } if (reverse) { - if (index > min && index <= max) { + if (index >= min && index <= max) { consumer.accept(index); index = index-step; return true; @@ -71,19 +87,17 @@ public int characteristics() { } @Override - public OfLong trySplit() { + public Spliterator.OfLong trySplit() { return this; } @Override - public ReversableSpliterator copy() { + public ReversingRangeLongSpliterator copy() { return new ReversingRangeLongSpliterator( - min, max, step,reverse); + min, max, step,reverse,start); } - /* (non-Javadoc) - * @see java.util.Spliterator.OfInt#forEachRemaining(java.util.function.IntConsumer) - */ + @Override public void forEachRemaining(LongConsumer action) { long index = this.index; //use local index making spliterator reusable @@ -95,7 +109,7 @@ public void forEachRemaining(LongConsumer action) { } } if (reverse) { - for( ;index > min && index <= max;) { + for( ;index >= min && index <= max;) { action.accept(index); index = index-step; @@ -104,9 +118,7 @@ public void forEachRemaining(LongConsumer action) { } } - /* (non-Javadoc) - * @see java.util.Spliterator.OfInt#forEachRemaining(java.util.function.Consumer) - */ + @Override public void forEachRemaining(Consumer action) { long index = this.index; //use local index making spliterator reusable @@ -117,7 +129,7 @@ public void forEachRemaining(Consumer action) { } } if (reverse) { - for( ;index > min && index <= max;) { + for( ;index >= min && index <= max;) { action.accept(index); index = index-step; } @@ -125,35 +137,6 @@ public void forEachRemaining(Consumer action) { } } - @Override - public Spliterator skip(long offset) { - if(reverse){ - return new ReversingRangeLongSpliterator( - min, max-(int)offset,step, reverse); - - }else{ - return new ReversingRangeLongSpliterator( - start+(int)offset, max,step, reverse); - } - - - } - - @Override - public Spliterator take(long number) { - if(reverse){ - return new ReversingRangeLongSpliterator( - max-(int)number, max, step,reverse); - - } - else{ - return new ReversingRangeLongSpliterator( - min, start+(int)number, step,reverse); - - } - - - } } diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/push/LimitLastOperator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/push/LimitLastOperator.java index f2b7e64651..208eba9f0b 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/push/LimitLastOperator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/push/LimitLastOperator.java @@ -1,6 +1,8 @@ package com.oath.cyclops.internal.stream.spliterators.push; import java.util.ArrayDeque; +import java.util.Deque; +import java.util.LinkedList; import java.util.function.Consumer; /** @@ -19,7 +21,7 @@ public LimitLastOperator(Operator source, int limit){ @Override public StreamSubscription subscribe(Consumer onNext, Consumer onError, Runnable onComplete) { - final ArrayDeque buffer = new ArrayDeque(limit); + final Deque buffer = limit < 1_000 ? new ArrayDeque(limit) : new LinkedList<>() ; StreamSubscription upstream[] = {null}; Runnable[] thunk = {()->{}}; StreamSubscription result = new StreamSubscription(){ diff --git a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/push/SkipLastOperator.java b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/push/SkipLastOperator.java index dcb888c3a6..677d2f4adc 100644 --- a/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/push/SkipLastOperator.java +++ b/cyclops/src/main/java/com/oath/cyclops/internal/stream/spliterators/push/SkipLastOperator.java @@ -2,6 +2,8 @@ package com.oath.cyclops.internal.stream.spliterators.push; import java.util.ArrayDeque; +import java.util.Deque; +import java.util.LinkedList; import java.util.function.Consumer; /** @@ -20,7 +22,7 @@ public SkipLastOperator(Operator source, long skip){ @Override public StreamSubscription subscribe(Consumer onNext, Consumer onError, Runnable onComplete) { - ArrayDeque buffer = new ArrayDeque(); + final Deque buffer = skip < 1_000 ? new ArrayDeque((int)skip) : new LinkedList<>() ; StreamSubscription sub[] = {null}; StreamSubscription res = new StreamSubscription(){ @Override diff --git a/cyclops/src/main/java/com/oath/cyclops/types/traversable/IterableX.java b/cyclops/src/main/java/com/oath/cyclops/types/traversable/IterableX.java index 7353b94138..5cd0c479b4 100644 --- a/cyclops/src/main/java/com/oath/cyclops/types/traversable/IterableX.java +++ b/cyclops/src/main/java/com/oath/cyclops/types/traversable/IterableX.java @@ -46,8 +46,12 @@ default boolean equalToIteration(Iterable iterable){ Iterator it2 = iterable.iterator(); Iterator it1 = iterator(); while(it2.hasNext() && it1.hasNext()){ - if(!Objects.equals(it2.next(),it1.next())) + T a = it2.next(); + T b= it1.next(); + if(!Objects.equals(a,b)) { + return false; + } } return it2.hasNext() == it1.hasNext(); } @@ -569,6 +573,8 @@ default IterableX prependAll(T... values) { } @Override default IterableX updateAt(int pos, T value) { + if(pos<0) + return this; return (IterableX)Traversable.super.updateAt(pos,value); } diff --git a/cyclops/src/main/java/com/oath/cyclops/types/traversable/Traversable.java b/cyclops/src/main/java/com/oath/cyclops/types/traversable/Traversable.java index 8393711d07..1740292665 100644 --- a/cyclops/src/main/java/com/oath/cyclops/types/traversable/Traversable.java +++ b/cyclops/src/main/java/com/oath/cyclops/types/traversable/Traversable.java @@ -776,6 +776,8 @@ default Traversable insertAt(int pos,ReactiveSeq values){ return traversable().insertAt(pos,values); } default Traversable updateAt(int i, T e){ + if(i<0) + return this; return traversable().updateAt(i,e); } default Traversable removeAt(long pos){ diff --git a/cyclops/src/main/java/cyclops/control/Option.java b/cyclops/src/main/java/cyclops/control/Option.java index 08598eabe3..fd78f2d4e1 100644 --- a/cyclops/src/main/java/cyclops/control/Option.java +++ b/cyclops/src/main/java/cyclops/control/Option.java @@ -109,9 +109,7 @@ static Option fromFuture(Future future){ return future.toOption(); } - /* (non-Javadoc) - * @see com.oath.cyclops.types.MonadicValue#concatMap(java.util.function.Function) - */ + @Override default Option concatMap(final Function> mapper) { return (Option) MonadicValue.super.concatMap(mapper); @@ -123,9 +121,7 @@ default Option orElseUse(Option opt){ return opt; } - /* (non-Javadoc) - * @see com.oath.cyclops.types.MonadicValue#flatMapP(java.util.function.Function) - */ + @Override default Option mergeMap(final Function> mapper) { return this.flatMap(a -> { diff --git a/cyclops/src/main/java/cyclops/data/ImmutableList.java b/cyclops/src/main/java/cyclops/data/ImmutableList.java index 497aa5937e..ed8af305f3 100644 --- a/cyclops/src/main/java/cyclops/data/ImmutableList.java +++ b/cyclops/src/main/java/cyclops/data/ImmutableList.java @@ -118,7 +118,9 @@ default ImmutableList removeFirst(Predicate pred){ default ImmutableList subList(int start, int end){ - return drop(start).take(end-start); + if(start>0) + return drop(start).take(end-start); + return take(end); } default LazySeq lazySeq(){ if(this instanceof LazySeq){ @@ -639,6 +641,8 @@ default ImmutableList dropUntil(Predicate p) { @Override default ImmutableList dropRight(int num) { + if(num>size()) + return emptyUnit(); return unitStream(stream().dropRight(num)); } diff --git a/cyclops/src/main/java/cyclops/data/LazySeq.java b/cyclops/src/main/java/cyclops/data/LazySeq.java index 3c713b262b..e1a36a17da 100644 --- a/cyclops/src/main/java/cyclops/data/LazySeq.java +++ b/cyclops/src/main/java/cyclops/data/LazySeq.java @@ -787,6 +787,8 @@ default LazySeq dropRight(int num) { @Override default LazySeq takeRight(int num) { + if(num>size()) + return this; return (LazySeq) ImmutableList.super.takeRight(num); } @@ -1173,7 +1175,8 @@ public LazySeq removeAt(final long i) { @Override public LazySeq updateAt(int i, T value) { - + if(i<0) + return this; return defer(()->{ if(i==0) { if(Objects.equals(head,value)) @@ -1181,6 +1184,8 @@ public LazySeq updateAt(int i, T value) { return cons(Eval.now(value), tail); } if(i>1000){ + if(i>size()-1) + return this; LazySeq front = take(i); LazySeq back = drop(i); @@ -1233,6 +1238,8 @@ public LazySeq append(Supplier> list) { @Override public LazySeq updateAt(int i, T value) { + if(i<0) + return this; return ref.get().updateAt(i,value); } diff --git a/cyclops/src/main/java/cyclops/data/LazyString.java b/cyclops/src/main/java/cyclops/data/LazyString.java index 129a5f8310..b47eca3f40 100644 --- a/cyclops/src/main/java/cyclops/data/LazyString.java +++ b/cyclops/src/main/java/cyclops/data/LazyString.java @@ -35,6 +35,7 @@ public static LazyString of(CharSequence seq){ return fromLazySeq(LazySeq.fromStream( seq.chars().mapToObj(i -> (char) i))); } + static Collector, LazyString> collector() { Collector> c = Collectors.toList(); return Collectors., Iterable,LazyString>collectingAndThen((Collector)c,LazyString::fromIterable); @@ -400,7 +401,7 @@ public int size(){ @Override public boolean isEmpty() { - return false; + return string.isEmpty(); } public int length(){ @@ -410,4 +411,13 @@ public String toString(){ return string.stream().join(""); } + @Override + public int hashCode() { + return this.string.hashCode(); + } + + @Override + public boolean equals(Object obj) { + return this.string.equals(obj); + } } diff --git a/cyclops/src/main/java/cyclops/data/Seq.java b/cyclops/src/main/java/cyclops/data/Seq.java index a37f7bd4e0..3a55d6eda7 100644 --- a/cyclops/src/main/java/cyclops/data/Seq.java +++ b/cyclops/src/main/java/cyclops/data/Seq.java @@ -814,6 +814,8 @@ public Seq removeAt(final long i) { @Override public Seq updateAt(int i, T value) { + if(i>size()-1) + return this; if(i==0) { if(Objects.equals(head,value)) return this; diff --git a/cyclops/src/main/java/cyclops/reactive/ReactiveSeq.java b/cyclops/src/main/java/cyclops/reactive/ReactiveSeq.java index 857a878ce4..6c0d1e0c27 100644 --- a/cyclops/src/main/java/cyclops/reactive/ReactiveSeq.java +++ b/cyclops/src/main/java/cyclops/reactive/ReactiveSeq.java @@ -2722,7 +2722,6 @@ default ReactiveSeq insertAt(int pos, ReactiveSeq values){ } long check = new Long(pos); boolean added[] = {false}; - // AtomicBoolean added = new AtomicBoolean(false); return ReactiveSeq.concat(zipWithIndex().flatMap(t -> { if (t._2() < check && !added[0]) @@ -3774,22 +3773,32 @@ default ReactiveSeq retry(final Function fn, fina } /** - * Remove all occurances of the specified element from the ReactiveSeq + * Remove first occurance of the specified element from the ReactiveSeq * * 
      * {@code
      * 	ReactiveSeq.of(1,2,3,4,5,1,2,3).removeValue(1)
      *
-     *  //Streamable[2,3,4,5,2,3]
+     *  //ReactiveSeq[2,3,4,5,1,2,3]
      * }
      *
* * @param t - * element to removeValue - * @return Filtered Stream / ReactiveSeq + * element to remove + * @return Filtered ReactiveSeq */ default ReactiveSeq removeValue(final T t) { - return this.filter(v -> v != t); + boolean[] found = {false}; + return this.filter(v -> { + if(found[0]) + return true; + if(v==t){ + found[0]=true; + return false; + } + return true; + + }); } diff --git a/cyclops/src/test/java/com/oath/cyclops/streams/BaseSequentialTest.java b/cyclops/src/test/java/com/oath/cyclops/streams/BaseSequentialTest.java index 024f5ede27..f7c7d24652 100644 --- a/cyclops/src/test/java/com/oath/cyclops/streams/BaseSequentialTest.java +++ b/cyclops/src/test/java/com/oath/cyclops/streams/BaseSequentialTest.java @@ -864,7 +864,8 @@ public void insertAtSOutOfRangeEmpty() { } @Test public void insertAtIOutOfRangeEmpty() { - for(int k=0;k result = of().insertAt(1, Arrays.asList(100)) .map(it -> it + "!!").collect(Collectors.toList()); diff --git a/cyclops/src/test/java/com/oath/cyclops/streams/CoreReactiveSeqTest.java b/cyclops/src/test/java/com/oath/cyclops/streams/CoreReactiveSeqTest.java index 009bc8e0c9..85c7b1d198 100644 --- a/cyclops/src/test/java/com/oath/cyclops/streams/CoreReactiveSeqTest.java +++ b/cyclops/src/test/java/com/oath/cyclops/streams/CoreReactiveSeqTest.java @@ -540,7 +540,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { diff --git a/cyclops/src/test/java/com/oath/cyclops/streams/RangeTest.java b/cyclops/src/test/java/com/oath/cyclops/streams/RangeTest.java index e5977491e7..67081845c4 100644 --- a/cyclops/src/test/java/com/oath/cyclops/streams/RangeTest.java +++ b/cyclops/src/test/java/com/oath/cyclops/streams/RangeTest.java @@ -60,13 +60,13 @@ public void longStreamCompare0(){ public void intStreamCompareReversed(){ - assertThat(11, + assertThat(0, equalTo(ReactiveSeq.range(-5,6).reverse().sumInt(i->i))); } @Test public void longStreamCompareReversed(){ - assertThat(11L, + assertThat(0L, equalTo(ReactiveSeq.rangeLong(-5,6).reverse().sumLong(i->i))); } @Test @@ -118,12 +118,12 @@ public void rangeLong(){ @Test public void rangeLongReversed(){ assertThat(ReactiveSeq.rangeLong(0,Long.MAX_VALUE).reverse() - .limit(2).toList(),equalTo(Arrays.asList(9223372036854775807l, 9223372036854775806l))); + .limit(2).toList(),equalTo(Arrays.asList(9223372036854775806l, 9223372036854775805l))); } @Test public void rangeLongReversedSkip(){ assertThat(ReactiveSeq.rangeLong(0,5).reverse() - .skip(3).toList(),equalTo(Arrays.asList(2l,1l))); + .skip(3).toList(),equalTo(Arrays.asList(1l,0l))); } @Test public void rangeLongSkip(){ @@ -138,12 +138,12 @@ public void rangeInt(){ @Test public void rangeIntReversed(){ assertThat(ReactiveSeq.range(0,Integer.MAX_VALUE).reverse() - .limit(2).toList(),equalTo(Arrays.asList(2147483647, 2147483646))); + .limit(2).toList(),equalTo(Arrays.asList(2147483646, 2147483645))); } @Test public void rangeIntReversedSkip2(){ assertThat(ReactiveSeq.range(0,5).reverse() - .skip(3).toList(),equalTo(Arrays.asList(2,1))); + .skip(3).toList(),equalTo(Arrays.asList(1,0))); } @Test @@ -155,13 +155,13 @@ public void rangeIntSkip2(){ @Test public void take2Reversed(){ ReactiveSeq.range(0,Integer.MAX_VALUE).reverse().limit(2).printOut(); - assertThat(ReactiveSeq.range(0,Integer.MAX_VALUE).reverse().limit(2).toList(),equalTo(Arrays.asList(2147483647, 2147483646))); + assertThat(ReactiveSeq.range(0,Integer.MAX_VALUE).reverse().limit(2).toList(),equalTo(Arrays.asList(2147483646, 2147483645))); } @Test public void rangeIntReversedSkip(){ assertThat(ReactiveSeq.range(0,Integer.MAX_VALUE).reverse() - .limit(10).skip(8).toList(),equalTo(Arrays.asList(2147483639, 2147483638))); + .limit(10).skip(8).toList(),equalTo(Arrays.asList(2147483638, 2147483637))); } @Test diff --git a/cyclops/src/test/java/com/oath/cyclops/streams/WindowingPushTest.java b/cyclops/src/test/java/com/oath/cyclops/streams/WindowingPushTest.java new file mode 100644 index 0000000000..b7b07d7abf --- /dev/null +++ b/cyclops/src/test/java/com/oath/cyclops/streams/WindowingPushTest.java @@ -0,0 +1,199 @@ +package com.oath.cyclops.streams; + +import cyclops.companion.Streamable; +import cyclops.data.Seq; +import cyclops.data.Vector; +import cyclops.reactive.ReactiveSeq; +import cyclops.reactive.Spouts; +import org.junit.Before; +import org.junit.Test; + +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import java.util.stream.Collectors; + +import static cyclops.reactive.Spouts.of; +import static org.hamcrest.Matchers.*; +import static org.junit.Assert.assertThat; + +public class WindowingPushTest { + ReactiveSeq empty; + ReactiveSeq nonEmpty; + + @Before + public void setup(){ + empty = of(); + nonEmpty = of(1); + } + + + + @Test + public void windowWhile(){ + assertThat(of(1,2,3,4,5,6) + .groupedWhile(i->i%3!=0) + .toList().size(),equalTo(2)); + assertThat(of(1,2,3,4,5,6) + .groupedWhile(i->i%3!=0) + .toList().get(0),equalTo(Seq.of(1,2,3))); + } + @Test + public void windowUntil(){ + assertThat(of(1,2,3,4,5,6) + .groupedUntil(i->i%3==0) + .toList().size(),equalTo(2)); + assertThat(of(1,2,3,4,5,6) + .groupedUntil(i->i%3==0) + .toList().get(0),equalTo(Seq.of(1,2,3))); + } + @Test + public void windowUntilEmpty(){ + assertThat(Spouts.of() + .groupedUntil(i->i%3==0) + .toList().size(),equalTo(0)); + } + @Test + public void windowStatefullyUntil(){ + System.out.println(of(1,2,3,4,5,6) + .groupedUntil((s, i)->s.containsValue(4) ? true : false) + .toList()); + + assertThat(of(1,2,3,4,5,6) + .groupedUntil((s, i)->s.containsValue(4) ? true : false) + .toList().size(),equalTo(2)); + + } + @Test + public void windowStatefullyUntilEmpty(){ + + assertThat(of() + .groupedUntil((s, i)->s.contains(4) ? true : false) + .toList().size(),equalTo(0)); + + } + @Test + public void windowStatefullyWhile(){ + System.out.println(of(1,2,3,4,5,6) + .groupedWhile((s, i)->s.containsValue(4) ? true : false) + .toList()); + + assertThat(of(1,2,3,4,5,6) + .groupedWhile((s, i)->s.containsValue(4) ? true : false) + .toList().size(),equalTo(4)); + + } + @Test + public void windowStatefullyWhileEmpty(){ + + assertThat(of() + .groupedWhile((s, i)->s.contains(4) ? true : false) + .toList().size(),equalTo(0)); + + } + @Test + public void sliding() { + List> list = of(1, 2, 3, 4, 5, 6).sliding(2).collect(Collectors.toList()); + + assertThat(list.get(0), hasItems(1, 2)); + assertThat(list.get(1), hasItems(2, 3)); + } + + @Test + public void slidingIncrement() { + List> list = of(1, 2, 3, 4, 5, 6).sliding(3, 2).collect(Collectors.toList()); + + System.out.println(list); + assertThat(list.get(0), hasItems(1, 2, 3)); + assertThat(list.get(1), hasItems(3, 4, 5)); + } + + @Test + public void grouped() { + + List> list = of(1, 2, 3, 4, 5, 6).grouped(3).collect(Collectors.toList()); + System.out.println(list); + assertThat(list.get(0), hasItems(1, 2, 3)); + assertThat(list.get(1), hasItems(4, 5, 6)); + + } + + @Test + public void sliding2() { + + + List> sliding = of(1, 2, 3, 4, 5).sliding(2).toList(); + + assertThat(sliding, contains(Seq.of(1, 2), Seq.of(2, 3), Seq.of(3, 4), Seq.of(4, 5))); + } + + @Test + public void slidingOverlap() { + + List> sliding = of(1, 2, 3, 4, 5).sliding(3,2).toList(); + + assertThat(sliding, contains(Seq.of(1, 2, 3), Seq.of(3, 4, 5))); + } + + @Test + public void slidingEmpty() { + + System.out.println("List " + of().sliding(1).toList()); + assertThat(of().sliding(1).toList().size(),equalTo(0)); + } + + @Test + public void slidingWithSmallWindowAtEnd() { + + + List> sliding = of(1, 2, 3, 4, 5).sliding(2,2).toList(); + + assertThat(sliding, contains(Seq.of(1, 2), Seq.of(3, 4), Seq.of(5))); + } + @Test + public void slidingWithSmallWindowAtEndIterative() { + + + Iterator> it = of(1, 2, 3, 4, 5).sliding(2,2).iterator(); + List> sliding = ReactiveSeq.fromIterator(it).toList(); + assertThat(sliding, contains(Seq.of(1, 2), Seq.of(3, 4), Seq.of(5))); + } + + @Test + public void groupedOnEmpty() throws Exception { + assertThat( empty.grouped(10).count(),equalTo(0l)); + } + + @Test + public void groupedEmpty0() throws Exception { + empty.grouped(0).toList(); + assertThat(of(1,2,3).grouped(0).toList(),equalTo(Arrays.asList(Vector.of(1,2,3)))); + + } + @Test + public void grouped0() throws Exception { + nonEmpty.grouped(0).toList(); + + } + + + + + @Test + public void groupedEmpty() throws Exception { + + assertThat(empty.grouped(1).count(),equalTo(0l)); + } + + @Test + public void groupedInfinite() { + ReactiveSeq infinite = Spouts.iterate(1, i->i+1); + + final ReactiveSeq> grouped = infinite.grouped(3); + assertThat(grouped.elementAt(0).toOptional().get(),equalTo(Vector.of(1,2,3))); + + } + +} + + diff --git a/cyclops/src/test/java/com/oath/cyclops/streams/WindowingTest.java b/cyclops/src/test/java/com/oath/cyclops/streams/WindowingTest.java index 453dd142cb..801efae366 100644 --- a/cyclops/src/test/java/com/oath/cyclops/streams/WindowingTest.java +++ b/cyclops/src/test/java/com/oath/cyclops/streams/WindowingTest.java @@ -6,12 +6,14 @@ import static org.hamcrest.Matchers.hasItems; import static org.junit.Assert.assertThat; +import java.util.Arrays; import java.util.Iterator; import java.util.List; import java.util.stream.Collectors; import cyclops.data.Seq; import cyclops.data.Vector; +import cyclops.reactive.Spouts; import org.junit.Before; import org.junit.Test; @@ -165,12 +167,13 @@ public void groupedOnEmpty() throws Exception { assertThat( empty.grouped(10).count(),equalTo(0l)); } - @Test(expected=IllegalArgumentException.class) + @Test public void groupedEmpty0() throws Exception { empty.grouped(0).toList(); + assertThat(Spouts.of(1,2,3).grouped(0).toList(),equalTo(Arrays.asList(Vector.of(1,2,3)))); } - @Test(expected=IllegalArgumentException.class) + @Test public void grouped0() throws Exception { nonEmpty.grouped(0).toList(); diff --git a/cyclops/src/test/java/com/oath/cyclops/streams/hotstream/PrimedConnectableTest.java b/cyclops/src/test/java/com/oath/cyclops/streams/hotstream/PrimedConnectableTest.java index fdcdf48fb9..008d998af9 100644 --- a/cyclops/src/test/java/com/oath/cyclops/streams/hotstream/PrimedConnectableTest.java +++ b/cyclops/src/test/java/com/oath/cyclops/streams/hotstream/PrimedConnectableTest.java @@ -114,7 +114,7 @@ public void hotStreamCaptureReversed() throws InterruptedException{ .limit(2) .toList(); - assertThat(list,equalTo(Arrays.asList(1000,999))); + assertThat(list,equalTo(Arrays.asList(999,998))); } volatile boolean active; diff --git a/cyclops/src/test/java/com/oath/cyclops/streams/streamable/BatchingTest.java b/cyclops/src/test/java/com/oath/cyclops/streams/streamable/BatchingTest.java index a526581a60..5cc7c3b735 100644 --- a/cyclops/src/test/java/com/oath/cyclops/streams/streamable/BatchingTest.java +++ b/cyclops/src/test/java/com/oath/cyclops/streams/streamable/BatchingTest.java @@ -328,7 +328,7 @@ public void windowBySizeAndTimeTime(){ public void batchBySizeSet(){ assertThat(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList().get(0).size(),is(1)); - assertThat(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList().get(1).size(),is(1)); + } @Test public void batchBySizeSetEmpty(){ diff --git a/cyclops/src/test/java/com/oath/cyclops/streams/streamable/WindowingTest.java b/cyclops/src/test/java/com/oath/cyclops/streams/streamable/WindowingTest.java index d5f532122b..b8bd3eca77 100644 --- a/cyclops/src/test/java/com/oath/cyclops/streams/streamable/WindowingTest.java +++ b/cyclops/src/test/java/com/oath/cyclops/streams/streamable/WindowingTest.java @@ -150,12 +150,12 @@ public void groupedOnEmpty() throws Exception { assertThat( empty.grouped(10).count(),equalTo(0l)); } - @Test(expected=IllegalArgumentException.class) + @Test public void groupedEmpty0() throws Exception { empty.grouped(0).toList(); } - @Test(expected=IllegalArgumentException.class) + @Test public void grouped0() throws Exception { nonEmpty.grouped(0).toList(); diff --git a/cyclops/src/test/java/cyclops/data/BagTest.java b/cyclops/src/test/java/cyclops/data/BagTest.java index c9a5e69567..57e31b2895 100644 --- a/cyclops/src/test/java/cyclops/data/BagTest.java +++ b/cyclops/src/test/java/cyclops/data/BagTest.java @@ -177,7 +177,7 @@ public void combineNoOrd(){ public void batchBySizeSet(){ System.out.println("List = " + of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList()); assertThat(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList().get(0).size(),is(1)); - assertThat(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList().size(),is(2)); + assertThat(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList().size(),is(1)); } @Test public void testCycleNoOrder() { diff --git a/cyclops/src/test/java/cyclops/data/LazyStringTest.java b/cyclops/src/test/java/cyclops/data/LazyStringTest.java new file mode 100644 index 0000000000..3d477579de --- /dev/null +++ b/cyclops/src/test/java/cyclops/data/LazyStringTest.java @@ -0,0 +1,744 @@ +package cyclops.data; + +import cyclops.control.Option; +import org.junit.Before; +import org.junit.Test; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Comparator; +import java.util.List; +import java.util.Objects; +import java.util.Random; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.hasItem; +import static org.hamcrest.Matchers.hasItems; +import static org.hamcrest.core.IsEqual.equalTo; +import static org.junit.Assert.*; + +public class LazyStringTest { + LazyString str = LazyString.of("hello world"); + LazyString strLines = LazyString.of("hello world\nboo hoo"); + LazyString caps = LazyString.of("HELLO WORLD"); + LazyString longStr = LazyString.of("the quick brown fox jumps over the dog"); + LazyString empty = LazyString.empty(); + + LazySeq helloWorld = LazySeq.of('h','e','l','l','o',' ','w','o','r','l','d'); + + + @Test + public void fromLazySeq() { + assertThat(empty,equalTo(LazyString.fromLazySeq(LazySeq.empty()))); + assertThat(str,equalTo(LazyString.fromLazySeq(helloWorld))); + } + + @Test + public void fromIterable() { + assertThat(empty,equalTo(LazyString.fromIterable(LazySeq.empty()))); + assertThat(str,equalTo(LazyString.fromIterable(helloWorld))); + } + + @Test + public void of() { + assertThat(empty,equalTo(LazyString.of(""))); + assertThat(str,equalTo(LazyString.of("hello world"))); + } + + @Test + public void collector() { + LazyString hw = Stream.of('h','e','l','l','o', ' ', 'w','o','r','l','d').collect(LazyString.collector()); + LazyString empty2 = Stream.empty().collect(LazyString.collector()); + + assertThat(str,equalTo(hw)); + assertThat(empty2,equalTo(empty)); + + } + + @Test + public void unitIterable() { + assertThat(empty.unitIterable(str),equalTo(str)); + assertThat(empty.unitIterable(str.lazySeq()),equalTo(str)); + } + @Test + public void unitStream() { + assertThat(empty.unitStream(str.stream()),equalTo(str)); + + } + + @Test + public void empty() { + assertThat(LazyString.empty(),equalTo(empty)); + } + + @Test + public void op() { + assertThat(str.op(s->s.reverse()),equalTo(str.reverse())); + } + + @Test + public void substring() { + assertThat(str.substring(6).toString(),equalTo("world")); + assertThat(empty.substring(6).toString(),equalTo("")); + } + + + @Test + public void substring1() { + assertThat(str.substring(0,5).toString(),equalTo("hello")); + assertThat(empty.substring(0,5).toString(),equalTo("")); + } + + @Test + public void toUpperCase() { + assertThat(str.toUpperCase().toString(),equalTo("HELLO WORLD")); + assertThat(empty.toUpperCase().toString(),equalTo("")); + } + + @Test + public void toLowerCase() { + assertThat(caps.toLowerCase().toString(),equalTo("hello world")); + assertThat(empty.toLowerCase().toString(),equalTo("")); + } + + @Test + public void words() { + assertThat(str.words().map(ls->ls.toString()),equalTo(LazySeq.of("hello", "world"))); + assertThat(empty.words().map(ls->ls.toString()),equalTo(LazySeq.empty())); + } + + @Test + public void lines() { + assertThat(str.lines().map(ls->ls.toString()),equalTo(LazySeq.of("hello world"))); + assertThat(strLines.lines().map(ls->ls.toString()),equalTo(LazySeq.of("hello world","boo hoo"))); + assertThat(empty.lines().map(ls->ls.toString()),equalTo(LazySeq.empty())); + } + + @Test + public void mapChar() { + assertThat(str.mapChar(c->new Character((char)(c+1))),equalTo(LazyString.of("ifmmp!xpsme"))); + assertThat(empty.mapChar(c->new Character((char)(c+1))),equalTo(LazyString.of(""))); + } + + @Test + public void flatMapChar() { + assertThat(str.flatMapChar(c->LazyString.of(""+new Character((char)(c+1)))),equalTo(LazyString.of("ifmmp!xpsme"))); + assertThat(empty.flatMapChar(c->LazyString.of(""+new Character((char)(c+1)))),equalTo(LazyString.of(""))); + } + + @Test + public void filter() { + assertThat(str.filter(i->!Objects.equals(i,'h')).toString(),equalTo("ello world")); + assertThat(empty.filter(i->!Objects.equals(i,'h')).toString(),equalTo("")); + } + + @Test + public void map() { + assertThat(str.map(i -> i + "1").vector().join(),equalTo("h1e1l1l1o1 1w1o1r1l1d1")); + assertThat(empty.map(i->i+"1").toString(),equalTo("[]")); + } + + @Test + public void flatMap() { + assertThat(str.flatMap(i -> LazySeq.of(i + "1")).vector().join(),equalTo("h1e1l1l1o1 1w1o1r1l1d1")); + assertThat(empty.flatMap(i-> LazySeq.of(i + "1")).toString(),equalTo("[]")); + } + + @Test + public void concatMap() { + assertThat(str.concatMap(i -> LazySeq.of(i + "1")).vector().join(),equalTo("h1e1l1l1o1 1w1o1r1l1d1")); + assertThat(empty.concatMap(i-> LazySeq.of(i + "1")).toString(),equalTo("[]")); + } + + @Test + public void mergeMap() { + + System.out.println(Vector.of("h1","e1","l1","l1","o1"," 1","w1","o1","r1","l1","d1")); + assertThat(str.mergeMap(i -> LazySeq.of(i + "1")).vector(),hasItems("h1","e1","l1","l1","o1"," 1","w1","o1","r1","l1","d1")); + assertThat(empty.mergeMap(i-> LazySeq.of(i + "1")).toString(),equalTo("[]")); + } + + @Test + public void mergeMap1() { + assertThat(str.mergeMap(10,i -> LazySeq.of(i + "1")).vector(),hasItems("h1","e1","l1","l1","o1"," 1","w1","o1","r1","l1","d1")); + assertThat(empty.mergeMap(10,i-> LazySeq.of(i + "1")).toString(),equalTo("[]")); + } + + @Test + public void fold() { + assertThat(str.fold(s->"10",n->"20"),equalTo("10")); + assertThat(empty.fold(s->"10",n->"20"),equalTo("20")); + } + + @Test + public void onEmpty() { + assertThat(str.onEmpty('a'),equalTo(str)); + assertThat(empty.onEmpty('a'),equalTo(LazyString.of("a"))); + } + + @Test + public void onEmptyGet() { + assertThat(str.onEmptyGet(()->'a'),equalTo(str)); + assertThat(empty.onEmptyGet(()->'a'),equalTo(LazyString.of("a"))); + } + + @Test + public void onEmptySwitch() { + assertThat(str.onEmptySwitch(()->empty),equalTo(str)); + assertThat(empty.onEmptySwitch(()->str),equalTo(str)); + } + + @Test + public void stream() { + assertThat(str.stream().join(),equalTo("hello world")); + assertThat(empty.stream().join(),equalTo("")); + } + + @Test + public void take() { + + assertThat(str.take(0).toString(), equalTo("")); + assertThat(str.take(-1).toString(), equalTo("")); + assertThat(str.take(1).toString(), equalTo("h")); + assertThat(str.take(2).toString(), equalTo("he")); + assertThat(str.take(2000).toString(), equalTo("hello world")); + + assertThat(empty.take(0).toString(), equalTo("")); + assertThat(empty.take(-1).toString(), equalTo("")); + assertThat(empty.take(1).toString(), equalTo("")); + assertThat(empty.take(2).toString(), equalTo("")); + assertThat(empty.take(2000).toString(), equalTo("")); + + } + + + @Test + public void emptyUnit() { + assertThat(str.emptyUnit(),equalTo(empty)); + } + + @Test + public void replaceFirst() { + assertThat(str.replaceFirst('l','b').toString(),equalTo("heblo world")); + assertThat(empty.replaceFirst('l','b').toString(),equalTo("")); + } + + @Test + public void removeFirst() { + assertThat(str.removeFirst(i->i=='l').toString(),equalTo("helo world")); + assertThat(empty.removeFirst(i->i=='l').toString(),equalTo("")); + } + + @Test + public void subList() { + assertThat(str.subList(0,str.length()),equalTo(str)); + assertThat(str.subList(-1100,Integer.MAX_VALUE),equalTo(str)); + assertThat(str.subList(0,5).toString(),equalTo("hello")); + assertThat(str.subList(6,11).toString(),equalTo("world")); + + assertThat(empty.subList(0,str.length()),equalTo(empty)); + assertThat(empty.subList(-1100,Integer.MAX_VALUE),equalTo(empty)); + assertThat(empty.subList(0,5).toString(),equalTo("")); + assertThat(empty.subList(6,11).toString(),equalTo("")); + } + + @Test + public void filterNot() { + assertThat(str.filterNot(i->i=='l').toString(),equalTo("heo word")); + } + + @Test + public void notNull() { + + assertThat(LazyString.fromIterable(Vector.of('h',null,'e')).notNull().toString(),equalTo("he")); + assertThat(LazyString.fromLazySeq(LazySeq.of('h',null,'e')).notNull().toString(),equalTo("he")); + + } + + boolean called; + @Test + public void peek() { + called = false; + LazyString s = str.take(1).peek(i->{ + called = true; + assertThat(i,equalTo('h')); + + }); + assertFalse(called); + s.join(); + assertTrue(called); + } + + @Test + public void tailOrElse() { + assertThat(str.tailOrElse(LazySeq.of('h')),equalTo(LazyString.of("ello world"))); + assertThat(empty.tailOrElse(LazySeq.of('h')),equalTo(LazyString.of("h"))); + } + + @Test + public void removeStream() { + + assertThat(str.removeStream(Stream.of('a','b','c')),equalTo(str)); + assertThat(str.removeStream(Stream.of('a','b','c','h')).toString(),equalTo("ello world")); + assertThat(str.removeStream(Stream.of('h','e','l','h')).toString(),equalTo("o word")); + + assertThat(empty.removeStream(Stream.of('a','b','c')),equalTo(empty)); + assertThat(empty.removeStream(Stream.of('a','b','c','h')).toString(),equalTo("")); + assertThat(empty.removeStream(Stream.of('h','e','l','h')).toString(),equalTo("")); + } + + @Test + public void removeAt() { + assertThat(str.removeAt(0),equalTo(LazyString.of("ello world"))); + assertThat(str.removeAt(1),equalTo(LazyString.of("hllo world"))); + assertThat(str.removeAt(10),equalTo(LazyString.of("hello worl"))); + assertThat(str.removeAt(-1),equalTo(str)); + assertThat(str.removeAt(100),equalTo(str)); + assertThat(str.removeAt(Integer.MAX_VALUE),equalTo(str)); + assertThat(str.removeAt(Integer.MAX_VALUE),equalTo(str)); + + assertThat(empty.removeAt(0),equalTo(LazyString.of(""))); + assertThat(empty.removeAt(1),equalTo(LazyString.of(""))); + assertThat(empty.removeAt(10),equalTo(LazyString.of(""))); + assertThat(empty.removeAt(-1),equalTo(empty)); + assertThat(empty.removeAt(100),equalTo(empty)); + assertThat(empty.removeAt(Integer.MAX_VALUE),equalTo(empty)); + assertThat(empty.removeAt(Integer.MAX_VALUE),equalTo(empty)); + } + + @Test + public void removeAll() { + assertThat(str.removeAll(),equalTo(str)); + assertThat(str.removeAll('l'),equalTo(LazyString.of("heo word"))); + + assertThat(empty.removeAll(),equalTo(empty)); + assertThat(empty.removeAll('l'),equalTo(empty)); + } + + @Test + public void retainAll() { + assertThat(str.retainAll(),equalTo(empty)); + assertThat(str.retainAll('l'),equalTo(LazyString.of("lll"))); + + assertThat(empty.retainAll(),equalTo(empty)); + assertThat(empty.retainAll('l'),equalTo(empty)); + } + + @Test + public void retainStream() { + assertThat(str.retainStream(Stream.of('a','b','c')),equalTo(empty)); + assertThat(str.retainStream(Stream.of('a','b','c','h')).toString(),equalTo("h")); + assertThat(str.retainStream(Stream.of('h','e','l','h')).toString(),equalTo("helll")); + + assertThat(empty.retainStream(Stream.of('a','b','c')),equalTo(empty)); + assertThat(empty.retainStream(Stream.of('a','b','c','h')).toString(),equalTo("")); + assertThat(empty.retainStream(Stream.of('h','e','l','h')).toString(),equalTo("")); + } + + @Test + public void retainAll1() { + assertThat(str.retainAll(Vector.empty()),equalTo(empty)); + assertThat(str.retainAll(Arrays.asList('l')),equalTo(LazyString.of("lll"))); + + assertThat(empty.retainAll(Vector.empty()),equalTo(empty)); + assertThat(empty.retainAll(Vector.of('l')),equalTo(empty)); + } + + @Test + public void distinct() { + assertThat(empty.distinct(),equalTo(empty)); + assertThat(str.distinct(),equalTo(LazyString.of("helo wrd"))); + } + + @Test + public void sorted() { + assertThat(empty.sorted(),equalTo(empty)); + assertThat(str.sorted().toString(),equalTo(" dehllloorw")); + } + + @Test + public void sorted1() { + assertThat(empty.sorted(),equalTo(empty)); + assertThat(str.sorted(new Comparator() { + @Override + public int compare(Character o1, Character o2) { + return -o1.compareTo(o2); + } + }).toString(),equalTo("wroolllhed ")); + } + + @Test + public void takeWhile() { + assertThat(empty.takeWhile(i->true),equalTo(empty)); + assertThat(empty.takeWhile(i->false),equalTo(empty)); + assertThat(str.takeWhile(i->true),equalTo(str)); + assertThat(str.takeWhile(i->false),equalTo(empty)); + } + + @Test + public void dropWhile() { + assertThat(empty.dropWhile(i->true),equalTo(empty)); + assertThat(empty.dropWhile(i->false),equalTo(empty)); + assertThat(str.dropWhile(i->true),equalTo(empty)); + assertThat(str.dropWhile(i->false),equalTo(str)); + } + + @Test + public void takeUntil() { + assertThat(empty.takeUntil(i->true),equalTo(empty)); + assertThat(empty.takeUntil(i->false),equalTo(empty)); + assertThat(str.takeUntil(i->true),equalTo(empty)); + assertThat(str.takeUntil(i->false),equalTo(str)); + } + + @Test + public void dropUntil() { + assertThat(empty.dropUntil(i->true),equalTo(empty)); + assertThat(empty.dropUntil(i->false),equalTo(empty)); + assertThat(str.dropUntil(i->true),equalTo(str)); + assertThat(str.dropUntil(i->false),equalTo(empty)); + } + + + @Test + public void dropRight() { + assertThat(empty.dropRight(2),equalTo(empty)); + assertThat(empty.dropRight(Integer.MAX_VALUE),equalTo(empty)); + assertThat(str.dropRight(Integer.MAX_VALUE),equalTo(empty)); + assertThat(str.dropRight(-2),equalTo(str)); + assertThat(str.dropRight(2).toString(),equalTo("hello wor")); + + } + + @Test + public void takeRight() { + assertThat(empty.takeRight(2),equalTo(empty)); + assertThat(empty.takeRight(Integer.MAX_VALUE),equalTo(empty)); + assertThat(str.takeRight(Integer.MAX_VALUE),equalTo(str)); + assertThat(str.takeRight(-2),equalTo(empty)); + assertThat(str.takeRight(2).toString(),equalTo("ld")); + } + + @Test + public void shuffle() { + assertThat(empty.shuffle(),equalTo(empty)); + List list = str.shuffle().listView(); + System.out.println(list); + assertThat(list,hasItems(str.lazySeq().listView().toArray(new Character[0]))); + } + + @Test + public void shuffle1() { + assertThat(empty.shuffle(new Random()),equalTo(empty)); + assertThat(str.shuffle(new Random()),hasItems(str.lazySeq().listView().toArray(new Character[0]))); + + } + + @Test + public void slice() { + assertThat(empty.slice(0,100),equalTo(empty)); + assertThat(empty.slice(-100,100),equalTo(empty)); + assertThat(empty.slice(-100,Integer.MAX_VALUE),equalTo(empty)); + + assertThat(str.slice(0,100),equalTo(str)); + assertThat(str.slice(-100,100),equalTo(str)); + assertThat(str.slice(-100,Integer.MAX_VALUE),equalTo(str)); + + assertThat(str.slice(3,7).toString(),equalTo("lo w")); + } + + @Test + public void sorted2() { + assertThat(empty.sorted(i->i.hashCode()),equalTo(empty)); + assertThat(str.sorted(i->i.hashCode()).toString(),equalTo(" dehllloorw")); + } + + @Test + public void prependStream() { + assertThat(empty.prependStream(str.stream()),equalTo(str)); + assertThat(str.prependStream(empty.stream()),equalTo(str)); + assertThat(str.prependStream(str.stream()).toString(),equalTo("hello worldhello world")); + assertThat(str.prependStream(LazyString.of("bob").stream()).toString(),equalTo("bobhello world")); + } + + @Test + public void appendAll() { + assertThat(empty.appendAll(str),equalTo(str)); + assertThat(str.appendAll(empty),equalTo(str)); + assertThat(str.appendAll(str).toString(),equalTo("hello worldhello world")); + assertThat(str.appendAll(LazyString.of("bob").stream()).toString(),equalTo("hello worldbob")); + } + + @Test + public void prependAll() { + assertThat(empty.prependAll(str.stream()),equalTo(str)); + assertThat(str.prependAll(empty.stream()),equalTo(str)); + assertThat(str.prependAll(str.stream()).toString(),equalTo("hello worldhello world")); + assertThat(str.prependAll(LazyString.of("bob").stream()).toString(),equalTo("bobhello world")); + } + + + @Test + public void hashCodeTest(){ + assertThat(empty.hashCode(),equalTo(LazySeq.empty().hashCode())); + } + @Test + public void deleteBetween() { + assertThat(empty.deleteBetween(0,100),equalTo(empty)); + assertThat(empty.deleteBetween(-10000,10000),equalTo(empty)); + assertThat(empty.deleteBetween(-10000,Integer.MAX_VALUE),equalTo(empty)); + + assertThat(str.deleteBetween(-10000,Integer.MAX_VALUE),equalTo(empty)); + assertThat(str.deleteBetween(0,100),equalTo(empty)); + assertThat(str.deleteBetween(-10000,10000),equalTo(empty)); + + assertThat(str.deleteBetween(2,5),equalTo(LazyString.of("he world"))); + assertThat(str.deleteBetween(2,Integer.MAX_VALUE),equalTo(LazyString.of("he"))); + } + + @Test + public void insertStreamAt() { + assertThat(empty.insertStreamAt(0,Stream.of('a','b')),equalTo(LazyString.of("ab"))); + assertThat(empty.insertStreamAt(1,Stream.of('a','b')),equalTo(LazyString.of("ab"))); + assertThat(empty.insertStreamAt(Integer.MAX_VALUE,Stream.of('a','b')),equalTo(LazyString.of("ab"))); + assertThat(empty.insertStreamAt(-1,Stream.of('a','b')),equalTo(LazyString.of("ab"))); + assertThat(empty.insertStreamAt(-10000,Stream.of('a','b')),equalTo(LazyString.of("ab"))); + + assertThat(str.insertStreamAt(0,Stream.of('a','b')),equalTo(LazyString.of("abhello world"))); + assertThat(str.insertStreamAt(1,Stream.of('a','b')),equalTo(LazyString.of("habello world"))); + assertThat(str.insertStreamAt(Integer.MAX_VALUE,Stream.of('a','b')),equalTo(LazyString.of("hello worldab"))); + assertThat(str.insertStreamAt(-1,Stream.of('a','b')),equalTo(LazyString.of("abhello world"))); + assertThat(str.insertStreamAt(-10000,Stream.of('a','b')),equalTo(LazyString.of("abhello world"))); + } + + @Test + public void plusAll() { + assertThat(empty.plusAll(str),equalTo(str)); + assertThat(str.plusAll(empty),equalTo(str)); + assertThat(str.plusAll(str).toString(),equalTo("hello worldhello world")); + assertThat(str.plusAll(LazyString.of("bob")).toString(),equalTo("bobhello world")); + + } + + @Test + public void plus() { + assertThat(empty.plus('a'),equalTo(LazyString.of("a"))); + assertThat(str.plus('a'),equalTo(LazyString.of("ahello world"))); + } + + @Test + public void removeValue() { + assertThat(empty.removeValue('h'),equalTo(empty)); + assertThat(str.removeValue('x'),equalTo(str)); + assertThat(str.removeValue('l'),equalTo(LazyString.of("helo world"))); + } + + @Test + public void removeAll1() { + assertThat(empty.removeAll('h'),equalTo(empty)); + assertThat(str.removeAll('x'),equalTo(str)); + assertThat(str.removeAll('l'),equalTo(LazyString.of("heo word"))); + assertThat(str.removeAll('l','e'),equalTo(LazyString.of("ho word"))); + assertThat(str.removeAll('l','e','o'),equalTo(LazyString.of("h wrd"))); + + assertThat(empty.removeAll(Seq.of('h')),equalTo(empty)); + assertThat(str.removeAll(Vector.of('x')),equalTo(str)); + assertThat(str.removeAll(Vector.of('l')),equalTo(LazyString.of("heo word"))); + assertThat(str.removeAll(Vector.of('l','e')),equalTo(LazyString.of("ho word"))); + assertThat(str.removeAll(Vector.of('l','e','o')),equalTo(LazyString.of("h wrd"))); + + + } + + @Test + public void updateAt() { + assertThat(empty.updateAt(0,'h'),equalTo(empty)); + assertThat(empty.updateAt(-100,'h'),equalTo(empty)); + assertThat(empty.updateAt(100,'h'),equalTo(empty)); + assertThat(empty.updateAt(Integer.MAX_VALUE,'h'),equalTo(empty)); + + + assertThat(str.updateAt(0,'x'),equalTo(LazyString.of("xello world"))); + assertThat(str.updateAt(1,'x'),equalTo(LazyString.of("hxllo world"))); + assertThat(str.updateAt(-100,'x'),equalTo(str)); + assertThat(str.updateAt(100,'x'),equalTo(str)); + assertThat(str.updateAt(Integer.MAX_VALUE,'x'),equalTo(str)); + } + + @Test + public void insertAt1() { + assertThat(empty.insertAt(0,'a'),equalTo(LazyString.of("a"))); + assertThat(empty.insertAt(1,'a'),equalTo(LazyString.of("a"))); + assertThat(empty.insertAt(Integer.MAX_VALUE,'a'),equalTo(LazyString.of("a"))); + assertThat(empty.insertAt(-1,'a'),equalTo(LazyString.of("a"))); + assertThat(empty.insertAt(-10000,'a'),equalTo(LazyString.of("a"))); + + assertThat(str.insertAt(0,'a'),equalTo(LazyString.of("ahello world"))); + assertThat(str.insertAt(1,'a'),equalTo(LazyString.of("haello world"))); + assertThat(str.insertAt(Integer.MAX_VALUE,'a'),equalTo(LazyString.of("hello worlda"))); + assertThat(str.insertAt(-1,'a'),equalTo(LazyString.of("ahello world"))); + assertThat(str.insertAt(-10000,'a'),equalTo(LazyString.of("ahello world"))); + } + + @Test + public void insertAt2() { + assertThat(empty.insertAt(0,'a','b'),equalTo(LazyString.of("ab"))); + assertThat(empty.insertAt(1,'a','b'),equalTo(LazyString.of("ab"))); + assertThat(empty.insertAt(Integer.MAX_VALUE,'a','b'),equalTo(LazyString.of("ab"))); + assertThat(empty.insertAt(-1,'a','b'),equalTo(LazyString.of("ab"))); + assertThat(empty.insertAt(-10000,'a','b'),equalTo(LazyString.of("ab"))); + + assertThat(str.insertAt(0,'a','b'),equalTo(LazyString.of("abhello world"))); + assertThat(str.insertAt(1,'a','b'),equalTo(LazyString.of("habello world"))); + assertThat(str.insertAt(Integer.MAX_VALUE,'a','b'),equalTo(LazyString.of("hello worldab"))); + assertThat(str.insertAt(-1,'a','b'),equalTo(LazyString.of("abhello world"))); + assertThat(str.insertAt(-10000,'a','b'),equalTo(LazyString.of("abhello world"))); + } + @Test + public void insertAt3() { + assertThat(empty.insertAt(0,Seq.of('a','b')),equalTo(LazyString.of("ab"))); + assertThat(empty.insertAt(1,Seq.of('a','b')),equalTo(LazyString.of("ab"))); + assertThat(empty.insertAt(Integer.MAX_VALUE,Seq.of('a','b')),equalTo(LazyString.of("ab"))); + assertThat(empty.insertAt(-1,Seq.of('a','b')),equalTo(LazyString.of("ab"))); + assertThat(empty.insertAt(-10000,Seq.of('a','b')),equalTo(LazyString.of("ab"))); + + assertThat(str.insertAt(0,Seq.of('a','b')),equalTo(LazyString.of("abhello world"))); + assertThat(str.insertAt(1,Seq.of('a','b')),equalTo(LazyString.of("habello world"))); + assertThat(str.insertAt(Integer.MAX_VALUE,Seq.of('a','b')),equalTo(LazyString.of("hello worldab"))); + assertThat(str.insertAt(-1,Seq.of('a','b')),equalTo(LazyString.of("abhello world"))); + assertThat(str.insertAt(-10000,Seq.of('a','b')),equalTo(LazyString.of("abhello world"))); + } + + @Test + public void drop() { + assertThat(empty.drop(-1),equalTo(empty)); + assertThat(empty.drop(-10000),equalTo(empty)); + assertThat(empty.drop(Integer.MAX_VALUE),equalTo(empty)); + assertThat(empty.drop(10),equalTo(empty)); + + assertThat(str.drop(-1),equalTo(str)); + assertThat(str.drop(-10000),equalTo(str)); + assertThat(str.drop(Integer.MAX_VALUE),equalTo(empty)); + assertThat(str.drop(50),equalTo(empty)); + assertThat(str.drop(5),equalTo(LazyString.of(" world"))); + } + + @Test + public void reverse() { + assertThat(empty.reverse(),equalTo(empty)); + assertThat(str.reverse().toString(),equalTo("dlrow olleh")); + } + + @Test + public void get() { + assertThat(empty.get(10),equalTo(Option.none())); + assertThat(empty.get(Integer.MAX_VALUE),equalTo(Option.none())); + assertThat(empty.get(-100),equalTo(Option.none())); + + assertThat(str.get(100),equalTo(Option.none())); + assertThat(str.get(Integer.MAX_VALUE),equalTo(Option.none())); + assertThat(str.get(-100),equalTo(Option.none())); + assertThat(str.get(1),equalTo(Option.some('e'))); + } + + @Test + public void getOrElse() { + assertThat(empty.getOrElse(10,'x'),equalTo('x')); + assertThat(empty.getOrElse(Integer.MAX_VALUE,'x'),equalTo('x')); + assertThat(empty.getOrElse(-100,'x'),equalTo('x')); + + assertThat(str.getOrElse(100,'x'),equalTo('x')); + assertThat(str.getOrElse(Integer.MAX_VALUE,'x'),equalTo('x')); + assertThat(str.getOrElse(-100,'x'),equalTo('x')); + assertThat(str.getOrElse(1,'x'),equalTo('e')); + } + + @Test + public void getOrElseGet() { + assertThat(empty.getOrElseGet(10,()->'x'),equalTo('x')); + assertThat(empty.getOrElseGet(Integer.MAX_VALUE,()->'x'),equalTo('x')); + assertThat(empty.getOrElseGet(-100,()->'x'),equalTo('x')); + + assertThat(str.getOrElseGet(100,()->'x'),equalTo('x')); + assertThat(str.getOrElseGet(Integer.MAX_VALUE,()->'x'),equalTo('x')); + assertThat(str.getOrElseGet(-100,()->'x'),equalTo('x')); + assertThat(str.getOrElseGet(1,()->'x'),equalTo('e')); + } + + @Test + public void prepend() { + assertThat(empty.prepend('a'),equalTo(LazyString.of("a"))); + assertThat(str.prepend('a'),equalTo(LazyString.of("ahello world"))); + } + + @Test + public void append() { + assertThat(empty.append('a'),equalTo(LazyString.of("a"))); + assertThat(str.append('a'),equalTo(LazyString.of("hello worlda"))); + } + + @Test + public void prependAll1() { + assertThat(empty.prependAll(str),equalTo(str)); + assertThat(str.prependAll(empty),equalTo(str)); + assertThat(str.prependAll(str).toString(),equalTo("hello worldhello world")); + assertThat(str.prependAll(LazyString.of("bob")).toString(),equalTo("bobhello world")); + } + + @Test + public void appendAll1() { + assertThat(empty.appendAll(str),equalTo(str)); + assertThat(str.appendAll(empty),equalTo(str)); + assertThat(str.appendAll(str).toString(),equalTo("hello worldhello world")); + assertThat(str.appendAll(LazyString.of("bob").stream()).toString(),equalTo("hello worldbob")); + } + + @Test + public void appendAll2() { + assertThat(empty.appendAll(str.toArray(i->new Character[i])),equalTo(str)); + assertThat(str.appendAll(empty.toArray(i->new Character[i])),equalTo(str)); + assertThat(str.appendAll(str.toArray(i->new Character[i])).toString(),equalTo("hello worldhello world")); + assertThat(str.appendAll(LazyString.of("bob").stream().toArray(i->new Character[i])).toString(),equalTo("hello worldbob")); + } + + @Test + public void prependAll2() { + assertThat(empty.prependAll(str.stream().toArray(i->new Character[i])),equalTo(str)); + assertThat(str.prependAll(empty.stream().toArray(i->new Character[i])),equalTo(str)); + assertThat(str.prependAll(str.stream().toArray(i->new Character[i])).toString(),equalTo("hello worldhello world")); + assertThat(str.prependAll(LazyString.of("bob").stream().toArray(i->new Character[i])).toString(),equalTo("bobhello world")); + } + + @Test + public void append1() { + assertThat(empty.append("a"),equalTo(LazyString.of("a"))); + assertThat(str.append("a"),equalTo(LazyString.of("hello worlda"))); + assertThat(str.append("ab"),equalTo(LazyString.of("hello worldab"))); + } + + @Test + public void size() { + assertThat(empty.size(),equalTo(0)); + assertThat(str.size(),equalTo("hello world".length())); + } + + @Test + public void isEmpty() { + assertThat(empty.isEmpty(),equalTo(true)); + assertThat(str.isEmpty(),equalTo(false)); + } + + @Test + public void length() { + assertThat(empty.length(),equalTo(0)); + assertThat(str.length(),equalTo("hello world".length())); + } + + @Test + public void toStringTest() { + assertThat(empty.toString(),equalTo("")); + assertThat(str.toString(),equalTo("hello world")); + } +} diff --git a/cyclops/src/test/java/cyclops/data/basetests/AbstractIterableXTest.java b/cyclops/src/test/java/cyclops/data/basetests/AbstractIterableXTest.java index 6a52a407b6..24b8f5cc1e 100644 --- a/cyclops/src/test/java/cyclops/data/basetests/AbstractIterableXTest.java +++ b/cyclops/src/test/java/cyclops/data/basetests/AbstractIterableXTest.java @@ -28,6 +28,7 @@ import cyclops.reactive.Spouts; import cyclops.companion.Streamable; +import org.hamcrest.core.IsEqual; import org.junit.Assert; import org.junit.Before; import org.junit.Ignore; @@ -81,6 +82,17 @@ public void deleteBetween(){ assertThat(result,equalTo(Arrays.asList("1!!","2!!","5!!","6!!"))); } @Test + public void deleteBetweenEmpty(){ + Assert.assertThat(empty.deleteBetween(0,100), IsEqual.equalTo(empty)); + Assert.assertThat(empty.deleteBetween(-10000,10000), IsEqual.equalTo(empty)); + Assert.assertThat(empty.deleteBetween(-10000,Integer.MAX_VALUE), IsEqual.equalTo(empty)); + } + @Test + public void deleteBetweenMax(){ + assertThat(of(1,2,3,4,5,6).deleteBetween(2,Integer.MAX_VALUE).size(),equalTo(2)); + assertThat(of(1,2,3,4,5,6).deleteBetween(0,Integer.MAX_VALUE).size(),equalTo(0)); + } + @Test public void insertAtIterable(){ List result = of(1,2,3).insertAt(1,of(100,200,300)) .map(it ->it+"!!").collect(Collectors.toList()); @@ -338,6 +350,7 @@ public void plusAllTwo(){ @Test public void minusOneLarge(){ + assertThat(range(0,10_000).size(),equalTo(10_000)); assertThat(range(0,10_000).removeValue(1).size(),equalTo(9999)); assertThat(range(0,10_000).append(1).removeValue(1).size(),equalTo(10000)); } @@ -551,6 +564,19 @@ public void slice(){ assertThat(empty().slice(0,2).size(),equalTo(0)); } + @Test + public void sliceTest(){ + Assert.assertThat(empty.slice(0,100), IsEqual.equalTo(empty)); + Assert.assertThat(empty.slice(-100,100), IsEqual.equalTo(empty)); + Assert.assertThat(empty.slice(-100,Integer.MAX_VALUE), IsEqual.equalTo(empty)); + + Assert.assertThat(of(1,2,3,4,5,6,7).slice(0,100), IsEqual.equalTo(of(1,2,3,4,5,6,7))); + Assert.assertThat(of(1,2,3,4,5,6,7).slice(-100,100), IsEqual.equalTo(of(1,2,3,4,5,6,7))); + Assert.assertThat(of(1,2,3,4,5,6,7).slice(-100,Integer.MAX_VALUE), IsEqual.equalTo(of(1,2,3,4,5,6,7))); + + Assert.assertThat(of(1,2,3,4,5,6,7).slice(3,7).size(), IsEqual.equalTo(4)); + } + @Test public void testTake(){ assertThat(of(1,2,3,4,5).take(2).collect(Collectors.toList()).size(),is(2)); @@ -619,6 +645,22 @@ public void dropRight(){ assertThat(of(1,2,3).dropRight(1).toList(),hasItems(1,2)); assertThat(of(1,2,3).dropRight(1).toList().size(),equalTo(2)); } + @Test + public void dropRightLarge(){ + assertThat(of(1,2,3).dropRight(Integer.MAX_VALUE).toList(),equalTo(Arrays.asList())); + } + @Test + public void dropRightNegative(){ + assertThat(of(1,2,3).dropRight(-10000).toList(),equalTo(Arrays.asList(1,2,3))); + } + @Test + public void takeRightLarge(){ + assertThat(of(1,2,3).takeRight(Integer.MAX_VALUE).toList(),equalTo(Arrays.asList(1,2,3))); + } + @Test + public void takeRightNegative(){ + assertThat(of(1,2,3).takeRight(-10000).toList(),equalTo(Arrays.asList())); + } @Test public void dropRightEmpty(){ assertThat(of().dropRight(1),equalTo(of())); @@ -938,8 +980,12 @@ public void windowStatefullyUntil(){ .groupedUntil((s, i)->s.containsValue(4) ? true : false).toList()); System.out.println(ReactiveSeq.of(1,2,3,4,5,6) .groupedUntil((s, i)->s.containsValue(4) ? true : false).toList()); + System.out.println(Spouts.of(1,2,3,4,5,6) + .groupedUntil((s, i)->s.containsValue(4) ? true : false).toList()); System.out.println(Streamable.of(1,2,3,4,5,6) .groupedUntil((s, i)->s.containsValue(4) ? true : false).toList()); + + assertThat(of(1,2,3,4,5,6) .groupedUntil((s, i)->s.containsValue(4) ? true : false) .toList().size(),equalTo(2)); @@ -1593,54 +1639,54 @@ public void zip4(){ } - @Test - public void notEqualNull(){ + public void notEqualNull() { assertFalse(empty().equals(null)); } - @Test - public void testReverse() { - assertThat( of(1, 2, 3).reverse().toList().size(), is(asList(3, 2, 1).size())); - } - - @Test - public void testShuffle() { - - Supplier> s = () ->of(1, 2, 3); - - assertEquals(3, ((IterableX)s.get().shuffle()).toList().size()); - assertThat(((IterableX)s.get().shuffle()).toList(), hasItems(1, 2, 3)); + @Test + public void testReverse() { + assertThat(of(1, 2, 3).reverse().toList().size(), is(asList(3, 2, 1).size())); + } + @Test + public void testShuffle() { - } - @Test - public void testShuffleRandom() { - Random r = new Random(); - Supplier> s = () ->of(1, 2, 3); + Supplier> s = () -> of(1, 2, 3); - assertEquals(3, ((IterableX)s.get()).shuffle(r).toList().size()); - assertThat(((IterableX)s.get()).shuffle(r).toList(), hasItems(1, 2, 3)); + assertEquals(3, ((IterableX) s.get().shuffle()).toList().size()); + assertThat(((IterableX) s.get().shuffle()).toList(), hasItems(1, 2, 3)); + } - } + @Test + public void shuffleEmpty() { + assertThat(empty().shuffle(), equalTo(empty())); + } + @Test + public void testShuffleRandom() { + Random r = new Random(); + Supplier> s = () -> of(1, 2, 3); + assertEquals(3, ((IterableX) s.get()).shuffle(r).toList().size()); + assertThat(((IterableX) s.get()).shuffle(r).toList(), hasItems(1, 2, 3)); + } - @Test - public void testMinByMaxBy2() { - Supplier> s = () -> of(1, 2, 3, 4, 5, 6); + @Test + public void testMinByMaxBy2() { + Supplier> s = () -> of(1, 2, 3, 4, 5, 6); - assertEquals(1, (int) s.get().maxBy(t -> Math.abs(t - 5)).orElse(-1)); - assertEquals(5, (int) s.get().minBy(t -> Math.abs(t - 5)).orElse(-1)); + assertEquals(1, (int) s.get().maxBy(t -> Math.abs(t - 5)).orElse(-1)); + assertEquals(5, (int) s.get().minBy(t -> Math.abs(t - 5)).orElse(-1)); - assertEquals(6, (int) s.get().maxBy(t -> "" + t).orElse(-1)); - assertEquals(1, (int) s.get().minBy(t -> "" + t).orElse(-1)); - } + assertEquals(6, (int) s.get().maxBy(t -> "" + t).orElse(-1)); + assertEquals(1, (int) s.get().minBy(t -> "" + t).orElse(-1)); + } @@ -2201,7 +2247,7 @@ public void plusAllSize(){ System.out.println("Vec1 " + vec); vec = vec.insertAt(Math.max(0,vec.size()),of(2)); - System.out.println("Vec " + vec); + // System.out.println("Vec " + vec.vector()); assertThat(vec,equalTo(of(1,2))); } @@ -2211,6 +2257,7 @@ public void withTest(){ assertEquals(of("x", "b", "c"), of("a", "b", "c").updateAt(0, "x")); assertEquals(of("a", "x", "c"), of("a", "b", "c").updateAt(1, "x")); assertEquals(of("a", "b", "x"), of("a", "b", "c").updateAt(2, "x")); + } @Test public void withLarge(){ @@ -2338,6 +2385,11 @@ public void updateAtOutOfRange2(){ assertThat(vec.updateAt(100,10),equalTo(of(5,2,1))); } + @Test + public void updateAtLargeOutOfRange(){ + assertThat(of(1,2,3).updateAt(100,-1), not(hasItem(-1))); + assertThat(of(1,2,3).updateAt(Integer.MAX_VALUE,-1), not(hasItem(-1))); + } @Test public void largePlusAll(){ assertThat(range(0,2000).insertAt(1010,of(-1,-2,-3)).size(),equalTo(2003)); @@ -2444,7 +2496,8 @@ public void batchBySize3(){ public void batchBySizeSet(){ System.out.println("List = " + of(1,1,1,1,1,1).grouped(3,()-> TreeSet.empty()).toList()); assertThat(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList().get(0).size(),is(1)); - assertThat(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList().size(),is(2)); + System.out.println(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList()); + assertThat(of(1,1,1,1,1,1).grouped(3,()->TreeSet.empty()).toList().size(),is(1)); } @Test public void batchBySizeSetEmpty(){ @@ -2612,7 +2665,7 @@ public void rangeLong(){ @Test public void rangeLongReversedSkip(){ System.out.println(rangeLong(0,5).reverse() - .drop(3)); + .drop(3).vector()); //0,1,2,3,4 : 4,3,2,1,0 1,0 assertThat(rangeLong(0,5).reverse() .drop(3).toList(),equalTo(Arrays.asList(1l,0l))); } @@ -2644,12 +2697,47 @@ public void rangeIntSkip2(){ .drop(3).toList(),equalTo(Arrays.asList(3,4))); } + @Test + public void rangeTest(){ + assertThat(range(0,10).vector(),hasItems(0,1,2,3,4,5,6,7,8,9)); + assertThat(range(0,10).reverse().vector(),hasItems(0,1,2,3,4,5,6,7,8,9)); + assertThat(range(0,10).reverse().vector(),not(hasItem(10))); + } + @Test public void take2Reversed(){ - range(0,10).reverse().take(2).printOut(); + System.out.println(Spouts.range(0,10).vector()); + System.out.println(ReactiveSeq.range(0,10).vector()); + System.out.println(range(0,10).reverse().vector()); + System.out.println("RS" + ReactiveSeq.range(0,10).reverse().vector()); assertThat(range(0,10).reverse().take(2).toList(),equalTo(Arrays.asList(9,8))); } @Test + public void take2ReversedLong(){ + System.out.println(Spouts.rangeLong(0,10).vector()); + System.out.println(ReactiveSeq.range(0,10).vector()); + System.out.println(range(0,10).reverse().vector()); + System.out.println(ReactiveSeq.range(0,10).reverse().vector()); + System.out.println(ReactiveSeq.rangeLong(0,10).reverse().vector()); + assertThat(rangeLong(0,10).reverse().take(2).toList(),equalTo(Arrays.asList(9l,8l))); + } + @Test + public void drop2Reversed(){ + System.out.println(Spouts.range(0,10).vector()); + System.out.println(ReactiveSeq.range(0,10).vector()); + System.out.println(range(0,10).reverse().vector()); + System.out.println("RS" + ReactiveSeq.range(0,10).reverse().vector()); + assertThat(range(0,10).reverse().drop(2).toList(),equalTo(Arrays.asList(7,6,5,4,3,2,1,0))); + } + @Test + public void drop2ReversedLong(){ + System.out.println(Spouts.rangeLong(0,10).vector()); + System.out.println(ReactiveSeq.range(0,10).vector()); + System.out.println(range(0,10).reverse().vector()); + System.out.println(ReactiveSeq.range(0,10).reverse().vector()); + assertThat(rangeLong(0,10).reverse().drop(2).toList(),equalTo(Arrays.asList(7l,6l,5l,4l,3l,2l,1l,0l))); + } + @Test public void rangeIntReversedSkip(){ assertThat(range(0,20).reverse() diff --git a/cyclops/src/test/java/cyclops/data/basetests/BaseImmutableSetTest.java b/cyclops/src/test/java/cyclops/data/basetests/BaseImmutableSetTest.java index a7409430f9..8ceb6bf185 100644 --- a/cyclops/src/test/java/cyclops/data/basetests/BaseImmutableSetTest.java +++ b/cyclops/src/test/java/cyclops/data/basetests/BaseImmutableSetTest.java @@ -16,6 +16,7 @@ import cyclops.data.ImmutableSet; import cyclops.data.tuple.Tuple2; import cyclops.reactive.ReactiveSeq; +import cyclops.reactive.Spouts; import org.junit.Ignore; import org.junit.Test; @@ -26,6 +27,7 @@ import static cyclops.data.tuple.Tuple.tuple; import static java.util.Arrays.asList; import static java.util.Comparator.comparing; +import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.*; import static org.junit.Assert.*; @@ -392,5 +394,33 @@ public void removeAllView(){ assertThat(list.removeAll(Arrays.asList(1)),equalTo(false)); } + @Test + public void drop2Reversed(){ + System.out.println(Spouts.range(0,10).vector()); + System.out.println(ReactiveSeq.range(0,10).vector()); + System.out.println(range(0,10).reverse().vector()); + System.out.println("RS" + ReactiveSeq.range(0,10).reverse().vector()); + assertThat(range(0,10).reverse().drop(2).toList().size(),equalTo(8)); + assertThat(range(0,10).reverse().drop(2).toList(),not(contains(10))); + } + @Test + public void drop2ReversedLong(){ + System.out.println(Spouts.rangeLong(0,10).vector()); + System.out.println(ReactiveSeq.range(0,10).vector()); + System.out.println(range(0,10).reverse().vector()); + System.out.println(ReactiveSeq.range(0,10).reverse().vector()); + assertThat(rangeLong(0,10).reverse().drop(2).toList().size(),equalTo(8)); + assertThat(rangeLong(0,10).reverse().drop(2).toList(),not(contains(10))); + } + @Test + public void take2ReversedLong(){ + System.out.println(Spouts.rangeLong(0,10).vector()); + System.out.println(ReactiveSeq.range(0,10).vector()); + System.out.println(range(0,10).reverse().vector()); + System.out.println(ReactiveSeq.range(0,10).reverse().vector()); + System.out.println(ReactiveSeq.rangeLong(0,10).reverse().vector()); + assertThat(rangeLong(0,10).reverse().take(2).toList().size(),equalTo(2)); + assertThat(rangeLong(0,10).reverse().take(2).toList(),not(contains(10))); + } } diff --git a/cyclops/src/test/java/cyclops/reactive/SpoutsTest.java b/cyclops/src/test/java/cyclops/reactive/SpoutsTest.java index 1d9e5f1d31..582e81348f 100644 --- a/cyclops/src/test/java/cyclops/reactive/SpoutsTest.java +++ b/cyclops/src/test/java/cyclops/reactive/SpoutsTest.java @@ -2,6 +2,7 @@ import com.oath.cyclops.types.reactive.AsyncSubscriber; import com.oath.cyclops.types.reactive.ReactiveSubscriber; +import com.oath.cyclops.types.traversable.IterableX; import cyclops.companion.Monoids; import cyclops.companion.Semigroups; import com.oath.cyclops.async.QueueFactories; @@ -34,6 +35,7 @@ import static cyclops.reactive.ReactiveSeq.of; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.greaterThan; import static org.hamcrest.Matchers.instanceOf; import static org.hamcrest.Matchers.isOneOf; @@ -56,6 +58,22 @@ public void setup(){ count=0; err = null; } + + @Test + public void plusAllSize(){ + + ReactiveSeq vec = Spouts.empty(); + vec = vec.insertAt(Math.max(0,vec.size()),Spouts.of(1)); + System.out.println("Vec1 " + vec.vector()); + vec = vec.insertAt(Math.max(0,vec.size()),Spouts.of(2)); + + // System.out.println("Vec " + vec.vector()); + /**Iterator it = vec.iterator(); + while(it.hasNext()){ + System.out.println(it.next()); + }**/ + assertThat(vec,equalTo(Spouts.of(1,2))); + } @Test public void rangeMaxConcurrencyM32() { List list =Spouts.range(0, 1_000_000).mergeMap(32,Flux::just).toList(); diff --git a/cyclops/src/test/java/cyclops/streams/BaseSequenceTest.java b/cyclops/src/test/java/cyclops/streams/BaseSequenceTest.java index 4019f0713d..0b9f5c1b3b 100644 --- a/cyclops/src/test/java/cyclops/streams/BaseSequenceTest.java +++ b/cyclops/src/test/java/cyclops/streams/BaseSequenceTest.java @@ -145,7 +145,7 @@ public void testReverseListLimitOneShot() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } diff --git a/cyclops/src/test/java/cyclops/streams/ReactiveSeqIterableXTest.java b/cyclops/src/test/java/cyclops/streams/ReactiveSeqIterableXTest.java new file mode 100644 index 0000000000..6af2e721e7 --- /dev/null +++ b/cyclops/src/test/java/cyclops/streams/ReactiveSeqIterableXTest.java @@ -0,0 +1,48 @@ +package cyclops.streams; + +import com.oath.cyclops.types.traversable.IterableX; +import cyclops.control.Option; +import cyclops.data.basetests.AbstractIterableXTest; +import cyclops.data.tuple.Tuple2; +import cyclops.reactive.ReactiveSeq; + +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.function.UnaryOperator; + +public class ReactiveSeqIterableXTest extends AbstractIterableXTest { + @Override + public IterableX empty() { + return ReactiveSeq.empty(); + } + + @Override + public IterableX of(T... values) { + return ReactiveSeq.of(values); + } + + @Override + public IterableX range(int start, int end) { + return ReactiveSeq.range(start,end); + } + + @Override + public IterableX rangeLong(long start, long end) { + return ReactiveSeq.rangeLong(start,end); + } + + @Override + public IterableX iterate(int times, T seed, UnaryOperator fn) { + return ReactiveSeq.iterate(seed,fn).take(times); + } + + @Override + public IterableX generate(int times, Supplier fn) { + return ReactiveSeq.generate(fn).take(times); + } + + @Override + public IterableX unfold(U seed, Function>> unfolder) { + return ReactiveSeq.unfold(seed,unfolder); + } +} diff --git a/cyclops/src/test/java/cyclops/streams/ReactiveSeqTest.java b/cyclops/src/test/java/cyclops/streams/ReactiveSeqTest.java index 139b5dc0bd..d5b3786ec7 100644 --- a/cyclops/src/test/java/cyclops/streams/ReactiveSeqTest.java +++ b/cyclops/src/test/java/cyclops/streams/ReactiveSeqTest.java @@ -629,7 +629,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test diff --git a/cyclops/src/test/java/cyclops/streams/push/CoreReactiveStreamXTest.java b/cyclops/src/test/java/cyclops/streams/push/CoreReactiveStreamXTest.java index 13b1f83b47..c4b970eac0 100644 --- a/cyclops/src/test/java/cyclops/streams/push/CoreReactiveStreamXTest.java +++ b/cyclops/src/test/java/cyclops/streams/push/CoreReactiveStreamXTest.java @@ -190,7 +190,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { diff --git a/cyclops/src/test/java/cyclops/streams/push/SpoutsIterableXTest.java b/cyclops/src/test/java/cyclops/streams/push/SpoutsIterableXTest.java new file mode 100644 index 0000000000..626f552840 --- /dev/null +++ b/cyclops/src/test/java/cyclops/streams/push/SpoutsIterableXTest.java @@ -0,0 +1,49 @@ +package cyclops.streams.push; + +import com.oath.cyclops.types.traversable.IterableX; +import cyclops.control.Option; +import cyclops.data.basetests.AbstractIterableXTest; +import cyclops.data.tuple.Tuple2; +import cyclops.reactive.ReactiveSeq; +import cyclops.reactive.Spouts; + +import java.util.function.Function; +import java.util.function.Supplier; +import java.util.function.UnaryOperator; + +public class SpoutsIterableXTest extends AbstractIterableXTest { + @Override + public IterableX empty() { + return Spouts.empty(); + } + + @Override + public IterableX of(T... values) { + return Spouts.of(values); + } + + @Override + public IterableX range(int start, int end) { + return Spouts.range(start,end); + } + + @Override + public IterableX rangeLong(long start, long end) { + return Spouts.rangeLong(start,end); + } + + @Override + public IterableX iterate(int times, T seed, UnaryOperator fn) { + return Spouts.iterate(seed,fn).take(times); + } + + @Override + public IterableX generate(int times, Supplier fn) { + return Spouts.generate(fn).take(times); + } + + @Override + public IterableX unfold(U seed, Function>> unfolder) { + return Spouts.unfold(seed,unfolder); + } +} diff --git a/cyclops/src/test/java/cyclops/streams/push/async/AsyncReactiveStreamXTest.java b/cyclops/src/test/java/cyclops/streams/push/async/AsyncReactiveStreamXTest.java index 78115bca3b..6ea3964683 100644 --- a/cyclops/src/test/java/cyclops/streams/push/async/AsyncReactiveStreamXTest.java +++ b/cyclops/src/test/java/cyclops/streams/push/async/AsyncReactiveStreamXTest.java @@ -201,7 +201,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { diff --git a/cyclops/src/test/java/cyclops/streams/push/asyncreactivestreams/AsyncRSReactiveStreamXTest.java b/cyclops/src/test/java/cyclops/streams/push/asyncreactivestreams/AsyncRSReactiveStreamXTest.java index dd2fb655d0..d83aefe23c 100644 --- a/cyclops/src/test/java/cyclops/streams/push/asyncreactivestreams/AsyncRSReactiveStreamXTest.java +++ b/cyclops/src/test/java/cyclops/streams/push/asyncreactivestreams/AsyncRSReactiveStreamXTest.java @@ -206,7 +206,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() { @@ -291,8 +291,8 @@ public void mergeMapToList(){ } @Test public void onEmptySwitchGet(){ - // for(int i=0;i 1).mergeMap(a->ReactiveSeq.of(1)) diff --git a/cyclops/src/test/java/cyclops/streams/push/syncflux/SyncReactiveStreamXTest.java b/cyclops/src/test/java/cyclops/streams/push/syncflux/SyncReactiveStreamXTest.java index 9bd858ae1e..4fcb0e9a95 100644 --- a/cyclops/src/test/java/cyclops/streams/push/syncflux/SyncReactiveStreamXTest.java +++ b/cyclops/src/test/java/cyclops/streams/push/syncflux/SyncReactiveStreamXTest.java @@ -184,7 +184,7 @@ public void testReverseListLimit() { public void testReverseRange() { assertThat( ReactiveSeq.range(0,10) - .reverse().toList(), equalTo(asList(10,9,8,7,6,5,4,3,2,1))); + .reverse().toList(), equalTo(asList(9,8,7,6,5,4,3,2,1,0))); } @Test public void testCycleLong() {