From e844de52c4c31726ccff9a3d30e6d38a2dab00eb Mon Sep 17 00:00:00 2001 From: zsxwing Date: Mon, 28 Oct 2013 17:57:50 +0800 Subject: [PATCH 1/4] Implemented the 'min' and 'max' operators --- .../main/java/rx/operators/OperationMax.java | 280 ++++++++++++++++++ .../main/java/rx/operators/OperationMin.java | 280 ++++++++++++++++++ 2 files changed, 560 insertions(+) create mode 100644 rxjava-core/src/main/java/rx/operators/OperationMax.java create mode 100644 rxjava-core/src/main/java/rx/operators/OperationMin.java diff --git a/rxjava-core/src/main/java/rx/operators/OperationMax.java b/rxjava-core/src/main/java/rx/operators/OperationMax.java new file mode 100644 index 0000000000..21a7b6105a --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationMax.java @@ -0,0 +1,280 @@ +/** + * Copyright 2013 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package rx.operators; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; + +import org.junit.Test; +import org.mockito.InOrder; + +import rx.Observable; +import rx.Observer; +import rx.util.functions.Func1; +import rx.util.functions.Func2; + +public class OperationMax { + + public static > Observable max( + Observable source) { + return source.reduce(new Func2() { + @Override + public T call(T acc, T value) { + if (acc.compareTo(value) > 0) { + return acc; + } + return value; + } + }); + } + + public static Observable max(Observable source, + final Comparator comparator) { + return source.reduce(new Func2() { + @Override + public T call(T acc, T value) { + if (comparator.compare(acc, value) > 0) { + return acc; + } + return value; + } + }); + } + + public static > Observable> maxBy( + Observable source, final Func1 selector) { + return source.reduce(new ArrayList(), + new Func2, T, List>() { + + @Override + public List call(List acc, T value) { + if (acc.isEmpty()) { + acc.add(value); + } else { + int flag = selector.call(acc.get(0)).compareTo( + selector.call(value)); + if (flag < 0) { + acc.clear(); + acc.add(value); + } else if (flag == 0) { + acc.add(value); + } + } + return acc; + } + }); + } + + public static Observable> maxBy(Observable source, + final Func1 selector, final Comparator comparator) { + return source.reduce(new ArrayList(), + new Func2, T, List>() { + + @Override + public List call(List acc, T value) { + if (acc.isEmpty()) { + acc.add(value); + } else { + int flag = comparator.compare( + selector.call(acc.get(0)), + selector.call(value)); + if (flag < 0) { + acc.clear(); + acc.add(value); + } else if (flag == 0) { + acc.add(value); + } + } + return acc; + } + }); + } + + public static class UnitTest { + + @Test + public void testMax() { + Observable observable = OperationMax.max(Observable.from( + 2, 3, 1, 4)); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(4); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithEmpty() { + Observable observable = OperationMax.max(Observable + . empty()); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + any(UnsupportedOperationException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithComparator() { + Observable observable = OperationMax.max( + Observable.from(2, 3, 1, 4), new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithComparatorAndEmpty() { + Observable observable = OperationMax.max( + Observable. empty(), new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + any(UnsupportedOperationException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxBy() { + Observable> observable = OperationMax.maxBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext( + Arrays.asList("1", "3", "5")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithEmpty() { + Observable> observable = OperationMax.maxBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithComparator() { + Observable> observable = OperationMax.maxBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext( + Arrays.asList("2", "4", "6")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithComparatorAndEmpty() { + Observable> observable = OperationMax.maxBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + } + +} diff --git a/rxjava-core/src/main/java/rx/operators/OperationMin.java b/rxjava-core/src/main/java/rx/operators/OperationMin.java new file mode 100644 index 0000000000..0b08a2f9ae --- /dev/null +++ b/rxjava-core/src/main/java/rx/operators/OperationMin.java @@ -0,0 +1,280 @@ +/** + * Copyright 2013 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package rx.operators; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; + +import org.junit.Test; +import org.mockito.InOrder; + +import rx.Observable; +import rx.Observer; +import rx.util.functions.Func1; +import rx.util.functions.Func2; + +public class OperationMin { + + public static > Observable min( + Observable source) { + return source.reduce(new Func2() { + @Override + public T call(T acc, T value) { + if (acc.compareTo(value) < 0) { + return acc; + } + return value; + } + }); + } + + public static Observable min(Observable source, + final Comparator comparator) { + return source.reduce(new Func2() { + @Override + public T call(T acc, T value) { + if (comparator.compare(acc, value) < 0) { + return acc; + } + return value; + } + }); + } + + public static > Observable> minBy( + Observable source, final Func1 selector) { + return source.reduce(new ArrayList(), + new Func2, T, List>() { + + @Override + public List call(List acc, T value) { + if (acc.isEmpty()) { + acc.add(value); + } else { + int flag = selector.call(acc.get(0)).compareTo( + selector.call(value)); + if (flag > 0) { + acc.clear(); + acc.add(value); + } else if (flag == 0) { + acc.add(value); + } + } + return acc; + } + }); + } + + public static Observable> minBy(Observable source, + final Func1 selector, final Comparator comparator) { + return source.reduce(new ArrayList(), + new Func2, T, List>() { + + @Override + public List call(List acc, T value) { + if (acc.isEmpty()) { + acc.add(value); + } else { + int flag = comparator.compare( + selector.call(acc.get(0)), + selector.call(value)); + if (flag > 0) { + acc.clear(); + acc.add(value); + } else if (flag == 0) { + acc.add(value); + } + } + return acc; + } + }); + } + + public static class UnitTest { + + @Test + public void testMin() { + Observable observable = OperationMin.min(Observable.from( + 2, 3, 1, 4)); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithEmpty() { + Observable observable = OperationMin.min(Observable + . empty()); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + any(UnsupportedOperationException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithComparator() { + Observable observable = OperationMin.min( + Observable.from(2, 3, 1, 4), new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(4); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithComparatorAndEmpty() { + Observable observable = OperationMin.min( + Observable. empty(), new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + any(UnsupportedOperationException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinBy() { + Observable> observable = OperationMin.minBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext( + Arrays.asList("2", "4", "6")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithEmpty() { + Observable> observable = OperationMin.minBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithComparator() { + Observable> observable = OperationMin.minBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext( + Arrays.asList("1", "3", "5")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithComparatorAndEmpty() { + Observable> observable = OperationMin.minBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + } + +} From 976ef36a9559a48a38d8f621902bf7a1d5ff1f3c Mon Sep 17 00:00:00 2001 From: zsxwing Date: Tue, 29 Oct 2013 11:08:31 +0800 Subject: [PATCH 2/4] Added the min and max operators in Observable and comments --- rxjava-core/src/main/java/rx/Observable.java | 110 ++++++++++++++++++ .../main/java/rx/operators/OperationMax.java | 3 + .../main/java/rx/operators/OperationMin.java | 3 + 3 files changed, 116 insertions(+) diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 3dcff7fb69..fe233a5574 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -52,8 +52,10 @@ import rx.operators.OperationLast; import rx.operators.OperationMap; import rx.operators.OperationMaterialize; +import rx.operators.OperationMax; import rx.operators.OperationMerge; import rx.operators.OperationMergeDelayError; +import rx.operators.OperationMin; import rx.operators.OperationMulticast; import rx.operators.OperationObserveOn; import rx.operators.OperationOnErrorResumeNextViaFunction; @@ -3631,6 +3633,114 @@ public static Observable averageDoubles(Observable source) { return OperationAverage.averageDoubles(source); } + /** + * Returns the minimum element in an observable sequence. + * For an empty source, it causes an {@link UnsupportedOperationException}. + * + * @param source + * an observable sequence to determine the minimum element of. + * @return an observable emitting the minimum element. + * @see MSDN: Observable.Min + */ + public static > Observable min(Observable source) { + return OperationMin.min(source); + } + + /** + * Returns the minimum element in an observable sequence according to the specified comparator. + * For an empty source, it causes an {@link UnsupportedOperationException}. + * + * @param comparator + * the comparer used to compare elements. + * @return an observable emitting the minimum value according to the specified comparator. + * @see MSDN: Observable.Min + */ + public Observable min(Comparator comparator) { + return OperationMin.min(this, comparator); + } + + /** + * Returns the elements in an observable sequence with the minimum key value. + * For an empty source, it returns an observable emitting an empty List. + * + * @param selector + * the key selector function. + * @return an observable emitting a List of the elements with the minimum key value. + * @see MSDN: Observable.MinBy + */ + public > Observable> minBy(Func1 selector) { + return OperationMin.minBy(this, selector); + } + + /** + * Returns the elements in an observable sequence with the minimum key value according to the specified comparator. + * For an empty source, it returns an observable emitting an empty List. + * + * @param selector + * the key selector function. + * @param comparator + * the comparator used to compare key values. + * @return an observable emitting a List of the elements with the minimum key value according to the specified comparator. + * @see MSDN: Observable.MinBy + */ + public Observable> minBy(Func1 selector, Comparator comparator) { + return OperationMin.minBy(this, selector, comparator); + } + + /** + * Returns the maximum element in an observable sequence. + * For an empty source, it causes an {@link UnsupportedOperationException}. + * + * @param source + * an observable sequence to determine the maximum element of. + * @return an observable emitting the maximum element. + * @see MSDN: Observable.Max + */ + public static > Observable max(Observable source) { + return OperationMax.max(source); + } + + /** + * Returns the maximum element in an observable sequence according to the specified comparator. + * For an empty source, it causes an {@link UnsupportedOperationException}. + * + * @param comparator + * the comparer used to compare elements. + * @return an observable emitting the maximum value according to the specified comparator. + * @see MSDN: Observable.Max + */ + public Observable max(Comparator comparator) { + return OperationMax.max(this, comparator); + } + + /** + * Returns the elements in an observable sequence with the maximum key value. + * For an empty source, it returns an observable emitting an empty List. + * + * @param selector + * the key selector function. + * @return an observable emitting a List of the elements with the maximum key value. + * @see MSDN: Observable.MaxBy + */ + public > Observable> maxBy(Func1 selector) { + return OperationMax.maxBy(this, selector); + } + + /** + * Returns the elements in an observable sequence with the maximum key value according to the specified comparator. + * For an empty source, it returns an observable emitting an empty List. + * + * @param selector + * the key selector function. + * @param comparator + * the comparator used to compare key values. + * @return an observable emitting a List of the elements with the maximum key value according to the specified comparator. + * @see MSDN: Observable.MaxBy + */ + public Observable> maxBy(Func1 selector, Comparator comparator) { + return OperationMax.maxBy(this, selector, comparator); + } + /** * Returns a {@link ConnectableObservable} that shares a single subscription to the underlying * Observable that will replay all of its items and notifications to any future {@link Observer}. diff --git a/rxjava-core/src/main/java/rx/operators/OperationMax.java b/rxjava-core/src/main/java/rx/operators/OperationMax.java index 21a7b6105a..1f462ed3fb 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMax.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMax.java @@ -33,6 +33,9 @@ import rx.util.functions.Func1; import rx.util.functions.Func2; +/** + * Returns the maximum element in an observable sequence. + */ public class OperationMax { public static > Observable max( diff --git a/rxjava-core/src/main/java/rx/operators/OperationMin.java b/rxjava-core/src/main/java/rx/operators/OperationMin.java index 0b08a2f9ae..632cd37ce5 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMin.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMin.java @@ -33,6 +33,9 @@ import rx.util.functions.Func1; import rx.util.functions.Func2; +/** + * Returns the minimum element in an observable sequence. + */ public class OperationMin { public static > Observable min( From 75b2ddd6fb2b694c7b16db5a2f057867597bbec9 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Fri, 8 Nov 2013 11:15:47 +0800 Subject: [PATCH 3/4] Separating unit tests out and update the comments --- rxjava-core/src/main/java/rx/Observable.java | 17 +- .../main/java/rx/operators/OperationMax.java | 177 ----------------- .../main/java/rx/operators/OperationMin.java | 177 ----------------- .../java/rx/operators/OperationMaxTest.java | 182 ++++++++++++++++++ .../java/rx/operators/OperationMinTest.java | 182 ++++++++++++++++++ 5 files changed, 377 insertions(+), 358 deletions(-) create mode 100644 rxjava-core/src/test/java/rx/operators/OperationMaxTest.java create mode 100644 rxjava-core/src/test/java/rx/operators/OperationMinTest.java diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index fe233a5574..3fbd7e6d37 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -19,6 +19,7 @@ import java.util.ArrayList; import java.util.Arrays; +import java.util.Comparator; import java.util.List; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Future; @@ -3635,11 +3636,13 @@ public static Observable averageDoubles(Observable source) { /** * Returns the minimum element in an observable sequence. - * For an empty source, it causes an {@link UnsupportedOperationException}. + * For an empty source, it causes an {@link IllegalArgumentException}. * * @param source * an observable sequence to determine the minimum element of. * @return an observable emitting the minimum element. + * @throws IllegalArgumentException + * if the source is empty * @see MSDN: Observable.Min */ public static > Observable min(Observable source) { @@ -3648,11 +3651,13 @@ public static > Observable min(Observable source) /** * Returns the minimum element in an observable sequence according to the specified comparator. - * For an empty source, it causes an {@link UnsupportedOperationException}. + * For an empty source, it causes an {@link IllegalArgumentException}. * * @param comparator * the comparer used to compare elements. * @return an observable emitting the minimum value according to the specified comparator. + * @throws IllegalArgumentException + * if the source is empty * @see MSDN: Observable.Min */ public Observable min(Comparator comparator) { @@ -3689,11 +3694,13 @@ public Observable> minBy(Func1 selector, Comparator compara /** * Returns the maximum element in an observable sequence. - * For an empty source, it causes an {@link UnsupportedOperationException}. + * For an empty source, it causes an {@link IllegalArgumentException}. * * @param source * an observable sequence to determine the maximum element of. * @return an observable emitting the maximum element. + * @throws IllegalArgumentException + * if the source is empty. * @see MSDN: Observable.Max */ public static > Observable max(Observable source) { @@ -3702,11 +3709,13 @@ public static > Observable max(Observable source) /** * Returns the maximum element in an observable sequence according to the specified comparator. - * For an empty source, it causes an {@link UnsupportedOperationException}. + * For an empty source, it causes an {@link IllegalArgumentException}. * * @param comparator * the comparer used to compare elements. * @return an observable emitting the maximum value according to the specified comparator. + * @throws IllegalArgumentException + * if the source is empty. * @see MSDN: Observable.Max */ public Observable max(Comparator comparator) { diff --git a/rxjava-core/src/main/java/rx/operators/OperationMax.java b/rxjava-core/src/main/java/rx/operators/OperationMax.java index 1f462ed3fb..bb22f8a33c 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMax.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMax.java @@ -15,21 +15,11 @@ */ package rx.operators; -import static org.mockito.Matchers.any; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; - import java.util.ArrayList; -import java.util.Arrays; import java.util.Comparator; import java.util.List; -import org.junit.Test; -import org.mockito.InOrder; - import rx.Observable; -import rx.Observer; import rx.util.functions.Func1; import rx.util.functions.Func2; @@ -113,171 +103,4 @@ public List call(List acc, T value) { }); } - public static class UnitTest { - - @Test - public void testMax() { - Observable observable = OperationMax.max(Observable.from( - 2, 3, 1, 4)); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(4); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxWithEmpty() { - Observable observable = OperationMax.max(Observable - . empty()); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onError( - any(UnsupportedOperationException.class)); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxWithComparator() { - Observable observable = OperationMax.max( - Observable.from(2, 3, 1, 4), new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(1); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxWithComparatorAndEmpty() { - Observable observable = OperationMax.max( - Observable. empty(), new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onError( - any(UnsupportedOperationException.class)); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxBy() { - Observable> observable = OperationMax.maxBy( - Observable.from("1", "2", "3", "4", "5", "6"), - new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext( - Arrays.asList("1", "3", "5")); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxByWithEmpty() { - Observable> observable = OperationMax.maxBy( - Observable. empty(), new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new ArrayList()); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxByWithComparator() { - Observable> observable = OperationMax.maxBy( - Observable.from("1", "2", "3", "4", "5", "6"), - new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext( - Arrays.asList("2", "4", "6")); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxByWithComparatorAndEmpty() { - Observable> observable = OperationMax.maxBy( - Observable. empty(), new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new ArrayList()); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - } - } diff --git a/rxjava-core/src/main/java/rx/operators/OperationMin.java b/rxjava-core/src/main/java/rx/operators/OperationMin.java index 632cd37ce5..13b1188f03 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMin.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMin.java @@ -15,21 +15,11 @@ */ package rx.operators; -import static org.mockito.Matchers.any; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; - import java.util.ArrayList; -import java.util.Arrays; import java.util.Comparator; import java.util.List; -import org.junit.Test; -import org.mockito.InOrder; - import rx.Observable; -import rx.Observer; import rx.util.functions.Func1; import rx.util.functions.Func2; @@ -113,171 +103,4 @@ public List call(List acc, T value) { }); } - public static class UnitTest { - - @Test - public void testMin() { - Observable observable = OperationMin.min(Observable.from( - 2, 3, 1, 4)); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(1); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinWithEmpty() { - Observable observable = OperationMin.min(Observable - . empty()); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onError( - any(UnsupportedOperationException.class)); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinWithComparator() { - Observable observable = OperationMin.min( - Observable.from(2, 3, 1, 4), new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(4); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinWithComparatorAndEmpty() { - Observable observable = OperationMin.min( - Observable. empty(), new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onError( - any(UnsupportedOperationException.class)); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinBy() { - Observable> observable = OperationMin.minBy( - Observable.from("1", "2", "3", "4", "5", "6"), - new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext( - Arrays.asList("2", "4", "6")); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinByWithEmpty() { - Observable> observable = OperationMin.minBy( - Observable. empty(), new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new ArrayList()); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinByWithComparator() { - Observable> observable = OperationMin.minBy( - Observable.from("1", "2", "3", "4", "5", "6"), - new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext( - Arrays.asList("1", "3", "5")); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinByWithComparatorAndEmpty() { - Observable> observable = OperationMin.minBy( - Observable. empty(), new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new ArrayList()); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - } - } diff --git a/rxjava-core/src/test/java/rx/operators/OperationMaxTest.java b/rxjava-core/src/test/java/rx/operators/OperationMaxTest.java new file mode 100644 index 0000000000..03c3ae5abd --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationMaxTest.java @@ -0,0 +1,182 @@ +package rx.operators; + +import static org.mockito.Matchers.isA; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; + +import org.junit.Test; +import org.mockito.InOrder; + +import rx.Observable; +import rx.Observer; +import rx.util.functions.Func1; + +public class OperationMaxTest { + @Test + public void testMax() { + Observable observable = OperationMax.max(Observable.from(2, 3, + 1, 4)); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(4); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithEmpty() { + Observable observable = OperationMax.max(Observable + . empty()); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithComparator() { + Observable observable = OperationMax.max( + Observable.from(2, 3, 1, 4), new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithComparatorAndEmpty() { + Observable observable = OperationMax.max( + Observable. empty(), new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxBy() { + Observable> observable = OperationMax.maxBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithEmpty() { + Observable> observable = OperationMax.maxBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithComparator() { + Observable> observable = OperationMax.maxBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithComparatorAndEmpty() { + Observable> observable = OperationMax.maxBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } +} diff --git a/rxjava-core/src/test/java/rx/operators/OperationMinTest.java b/rxjava-core/src/test/java/rx/operators/OperationMinTest.java new file mode 100644 index 0000000000..971baf1ddb --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationMinTest.java @@ -0,0 +1,182 @@ +package rx.operators; + +import static org.mockito.Matchers.isA; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; + +import org.junit.Test; +import org.mockito.InOrder; + +import rx.Observable; +import rx.Observer; +import rx.util.functions.Func1; + +public class OperationMinTest { + @Test + public void testMin() { + Observable observable = OperationMin.min(Observable.from(2, 3, + 1, 4)); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithEmpty() { + Observable observable = OperationMin.min(Observable + . empty()); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithComparator() { + Observable observable = OperationMin.min( + Observable.from(2, 3, 1, 4), new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(4); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithComparatorAndEmpty() { + Observable observable = OperationMin.min( + Observable. empty(), new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinBy() { + Observable> observable = OperationMin.minBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithEmpty() { + Observable> observable = OperationMin.minBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithComparator() { + Observable> observable = OperationMin.minBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithComparatorAndEmpty() { + Observable> observable = OperationMin.minBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } +} From db04d566dbb6911bfbcf13d69b4469964ea50847 Mon Sep 17 00:00:00 2001 From: zsxwing Date: Mon, 11 Nov 2013 19:40:36 +0800 Subject: [PATCH 4/4] Use the '+1/-1' way to implement the min and max operators --- rxjava-core/src/main/java/rx/Observable.java | 23 +- .../main/java/rx/operators/OperationMax.java | 106 ------ ...OperationMin.java => OperationMinMax.java} | 77 +++- .../java/rx/operators/OperationMaxTest.java | 182 --------- .../rx/operators/OperationMinMaxTest.java | 359 ++++++++++++++++++ .../java/rx/operators/OperationMinTest.java | 182 --------- 6 files changed, 431 insertions(+), 498 deletions(-) delete mode 100644 rxjava-core/src/main/java/rx/operators/OperationMax.java rename rxjava-core/src/main/java/rx/operators/{OperationMin.java => OperationMinMax.java} (59%) delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationMaxTest.java create mode 100644 rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java delete mode 100644 rxjava-core/src/test/java/rx/operators/OperationMinTest.java diff --git a/rxjava-core/src/main/java/rx/Observable.java b/rxjava-core/src/main/java/rx/Observable.java index 3fbd7e6d37..08c0b47192 100644 --- a/rxjava-core/src/main/java/rx/Observable.java +++ b/rxjava-core/src/main/java/rx/Observable.java @@ -53,10 +53,9 @@ import rx.operators.OperationLast; import rx.operators.OperationMap; import rx.operators.OperationMaterialize; -import rx.operators.OperationMax; import rx.operators.OperationMerge; import rx.operators.OperationMergeDelayError; -import rx.operators.OperationMin; +import rx.operators.OperationMinMax; import rx.operators.OperationMulticast; import rx.operators.OperationObserveOn; import rx.operators.OperationOnErrorResumeNextViaFunction; @@ -3636,6 +3635,7 @@ public static Observable averageDoubles(Observable source) { /** * Returns the minimum element in an observable sequence. + * If there are more than one minimum elements, returns the last one. * For an empty source, it causes an {@link IllegalArgumentException}. * * @param source @@ -3646,11 +3646,12 @@ public static Observable averageDoubles(Observable source) { * @see MSDN: Observable.Min */ public static > Observable min(Observable source) { - return OperationMin.min(source); + return OperationMinMax.min(source); } /** * Returns the minimum element in an observable sequence according to the specified comparator. + * If there are more than one minimum elements, returns the last one. * For an empty source, it causes an {@link IllegalArgumentException}. * * @param comparator @@ -3661,7 +3662,7 @@ public static > Observable min(Observable source) * @see MSDN: Observable.Min */ public Observable min(Comparator comparator) { - return OperationMin.min(this, comparator); + return OperationMinMax.min(this, comparator); } /** @@ -3674,7 +3675,7 @@ public Observable min(Comparator comparator) { * @see MSDN: Observable.MinBy */ public > Observable> minBy(Func1 selector) { - return OperationMin.minBy(this, selector); + return OperationMinMax.minBy(this, selector); } /** @@ -3689,11 +3690,12 @@ public > Observable> minBy(Func1 selector) * @see MSDN: Observable.MinBy */ public Observable> minBy(Func1 selector, Comparator comparator) { - return OperationMin.minBy(this, selector, comparator); + return OperationMinMax.minBy(this, selector, comparator); } /** * Returns the maximum element in an observable sequence. + * If there are more than one maximum elements, returns the last one. * For an empty source, it causes an {@link IllegalArgumentException}. * * @param source @@ -3704,11 +3706,12 @@ public Observable> minBy(Func1 selector, Comparator compara * @see MSDN: Observable.Max */ public static > Observable max(Observable source) { - return OperationMax.max(source); + return OperationMinMax.max(source); } /** * Returns the maximum element in an observable sequence according to the specified comparator. + * If there are more than one maximum elements, returns the last one. * For an empty source, it causes an {@link IllegalArgumentException}. * * @param comparator @@ -3719,7 +3722,7 @@ public static > Observable max(Observable source) * @see MSDN: Observable.Max */ public Observable max(Comparator comparator) { - return OperationMax.max(this, comparator); + return OperationMinMax.max(this, comparator); } /** @@ -3732,7 +3735,7 @@ public Observable max(Comparator comparator) { * @see MSDN: Observable.MaxBy */ public > Observable> maxBy(Func1 selector) { - return OperationMax.maxBy(this, selector); + return OperationMinMax.maxBy(this, selector); } /** @@ -3747,7 +3750,7 @@ public > Observable> maxBy(Func1 selector) * @see MSDN: Observable.MaxBy */ public Observable> maxBy(Func1 selector, Comparator comparator) { - return OperationMax.maxBy(this, selector, comparator); + return OperationMinMax.maxBy(this, selector, comparator); } /** diff --git a/rxjava-core/src/main/java/rx/operators/OperationMax.java b/rxjava-core/src/main/java/rx/operators/OperationMax.java deleted file mode 100644 index bb22f8a33c..0000000000 --- a/rxjava-core/src/main/java/rx/operators/OperationMax.java +++ /dev/null @@ -1,106 +0,0 @@ -/** - * Copyright 2013 Netflix, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package rx.operators; - -import java.util.ArrayList; -import java.util.Comparator; -import java.util.List; - -import rx.Observable; -import rx.util.functions.Func1; -import rx.util.functions.Func2; - -/** - * Returns the maximum element in an observable sequence. - */ -public class OperationMax { - - public static > Observable max( - Observable source) { - return source.reduce(new Func2() { - @Override - public T call(T acc, T value) { - if (acc.compareTo(value) > 0) { - return acc; - } - return value; - } - }); - } - - public static Observable max(Observable source, - final Comparator comparator) { - return source.reduce(new Func2() { - @Override - public T call(T acc, T value) { - if (comparator.compare(acc, value) > 0) { - return acc; - } - return value; - } - }); - } - - public static > Observable> maxBy( - Observable source, final Func1 selector) { - return source.reduce(new ArrayList(), - new Func2, T, List>() { - - @Override - public List call(List acc, T value) { - if (acc.isEmpty()) { - acc.add(value); - } else { - int flag = selector.call(acc.get(0)).compareTo( - selector.call(value)); - if (flag < 0) { - acc.clear(); - acc.add(value); - } else if (flag == 0) { - acc.add(value); - } - } - return acc; - } - }); - } - - public static Observable> maxBy(Observable source, - final Func1 selector, final Comparator comparator) { - return source.reduce(new ArrayList(), - new Func2, T, List>() { - - @Override - public List call(List acc, T value) { - if (acc.isEmpty()) { - acc.add(value); - } else { - int flag = comparator.compare( - selector.call(acc.get(0)), - selector.call(value)); - if (flag < 0) { - acc.clear(); - acc.add(value); - } else if (flag == 0) { - acc.add(value); - } - } - return acc; - } - }); - } - -} diff --git a/rxjava-core/src/main/java/rx/operators/OperationMin.java b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java similarity index 59% rename from rxjava-core/src/main/java/rx/operators/OperationMin.java rename to rxjava-core/src/main/java/rx/operators/OperationMinMax.java index 13b1188f03..ba587751e8 100644 --- a/rxjava-core/src/main/java/rx/operators/OperationMin.java +++ b/rxjava-core/src/main/java/rx/operators/OperationMinMax.java @@ -26,14 +26,54 @@ /** * Returns the minimum element in an observable sequence. */ -public class OperationMin { +public class OperationMinMax { public static > Observable min( Observable source) { + return minMax(source, -1L); + } + + public static Observable min(Observable source, + final Comparator comparator) { + return minMax(source, comparator, -1L); + } + + public static > Observable> minBy( + Observable source, final Func1 selector) { + return minMaxBy(source, selector, -1L); + } + + public static Observable> minBy(Observable source, + final Func1 selector, final Comparator comparator) { + return minMaxBy(source, selector, comparator, -1L); + } + + public static > Observable max( + Observable source) { + return minMax(source, 1L); + } + + public static Observable max(Observable source, + final Comparator comparator) { + return minMax(source, comparator, 1L); + } + + public static > Observable> maxBy( + Observable source, final Func1 selector) { + return minMaxBy(source, selector, 1L); + } + + public static Observable> maxBy(Observable source, + final Func1 selector, final Comparator comparator) { + return minMaxBy(source, selector, comparator, 1L); + } + + private static > Observable minMax( + Observable source, final long flag) { return source.reduce(new Func2() { @Override public T call(T acc, T value) { - if (acc.compareTo(value) < 0) { + if (flag * acc.compareTo(value) > 0) { return acc; } return value; @@ -41,12 +81,12 @@ public T call(T acc, T value) { }); } - public static Observable min(Observable source, - final Comparator comparator) { + private static Observable minMax(Observable source, + final Comparator comparator, final long flag) { return source.reduce(new Func2() { @Override public T call(T acc, T value) { - if (comparator.compare(acc, value) < 0) { + if (flag * comparator.compare(acc, value) > 0) { return acc; } return value; @@ -54,8 +94,8 @@ public T call(T acc, T value) { }); } - public static > Observable> minBy( - Observable source, final Func1 selector) { + private static > Observable> minMaxBy( + Observable source, final Func1 selector, final long flag) { return source.reduce(new ArrayList(), new Func2, T, List>() { @@ -64,12 +104,12 @@ public List call(List acc, T value) { if (acc.isEmpty()) { acc.add(value); } else { - int flag = selector.call(acc.get(0)).compareTo( - selector.call(value)); - if (flag > 0) { - acc.clear(); + int compareResult = selector.call(acc.get(0)) + .compareTo(selector.call(value)); + if (compareResult == 0) { acc.add(value); - } else if (flag == 0) { + } else if (flag * compareResult < 0) { + acc.clear(); acc.add(value); } } @@ -78,8 +118,9 @@ public List call(List acc, T value) { }); } - public static Observable> minBy(Observable source, - final Func1 selector, final Comparator comparator) { + private static Observable> minMaxBy(Observable source, + final Func1 selector, final Comparator comparator, + final long flag) { return source.reduce(new ArrayList(), new Func2, T, List>() { @@ -88,13 +129,13 @@ public List call(List acc, T value) { if (acc.isEmpty()) { acc.add(value); } else { - int flag = comparator.compare( + int compareResult = comparator.compare( selector.call(acc.get(0)), selector.call(value)); - if (flag > 0) { - acc.clear(); + if (compareResult == 0) { acc.add(value); - } else if (flag == 0) { + } else if (flag * compareResult < 0) { + acc.clear(); acc.add(value); } } diff --git a/rxjava-core/src/test/java/rx/operators/OperationMaxTest.java b/rxjava-core/src/test/java/rx/operators/OperationMaxTest.java deleted file mode 100644 index 03c3ae5abd..0000000000 --- a/rxjava-core/src/test/java/rx/operators/OperationMaxTest.java +++ /dev/null @@ -1,182 +0,0 @@ -package rx.operators; - -import static org.mockito.Matchers.isA; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Comparator; -import java.util.List; - -import org.junit.Test; -import org.mockito.InOrder; - -import rx.Observable; -import rx.Observer; -import rx.util.functions.Func1; - -public class OperationMaxTest { - @Test - public void testMax() { - Observable observable = OperationMax.max(Observable.from(2, 3, - 1, 4)); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(4); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxWithEmpty() { - Observable observable = OperationMax.max(Observable - . empty()); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onError( - isA(IllegalArgumentException.class)); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxWithComparator() { - Observable observable = OperationMax.max( - Observable.from(2, 3, 1, 4), new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(1); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxWithComparatorAndEmpty() { - Observable observable = OperationMax.max( - Observable. empty(), new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onError( - isA(IllegalArgumentException.class)); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxBy() { - Observable> observable = OperationMax.maxBy( - Observable.from("1", "2", "3", "4", "5", "6"), - new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5")); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxByWithEmpty() { - Observable> observable = OperationMax.maxBy( - Observable. empty(), new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new ArrayList()); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxByWithComparator() { - Observable> observable = OperationMax.maxBy( - Observable.from("1", "2", "3", "4", "5", "6"), - new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6")); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMaxByWithComparatorAndEmpty() { - Observable> observable = OperationMax.maxBy( - Observable. empty(), new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new ArrayList()); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } -} diff --git a/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java new file mode 100644 index 0000000000..f2deff9e57 --- /dev/null +++ b/rxjava-core/src/test/java/rx/operators/OperationMinMaxTest.java @@ -0,0 +1,359 @@ +/** + * Copyright 2013 Netflix, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package rx.operators; + +import static org.mockito.Matchers.isA; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static rx.operators.OperationMinMax.max; +import static rx.operators.OperationMinMax.maxBy; +import static rx.operators.OperationMinMax.min; +import static rx.operators.OperationMinMax.minBy; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; + +import org.junit.Test; +import org.mockito.InOrder; + +import rx.Observable; +import rx.Observer; +import rx.util.functions.Func1; + +public class OperationMinMaxTest { + @Test + public void testMin() { + Observable observable = min(Observable.from(2, 3, 1, 4)); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithEmpty() { + Observable observable = min(Observable. empty()); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithComparator() { + Observable observable = min(Observable.from(2, 3, 1, 4), + new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(4); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinWithComparatorAndEmpty() { + Observable observable = min(Observable. empty(), + new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinBy() { + Observable> observable = minBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithEmpty() { + Observable> observable = minBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithComparator() { + Observable> observable = minBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMinByWithComparatorAndEmpty() { + Observable> observable = minBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMax() { + Observable observable = max(Observable.from(2, 3, 1, 4)); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(4); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithEmpty() { + Observable observable = max(Observable. empty()); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithComparator() { + Observable observable = max(Observable.from(2, 3, 1, 4), + new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(1); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxWithComparatorAndEmpty() { + Observable observable = max(Observable. empty(), + new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer observer = (Observer) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onError( + isA(IllegalArgumentException.class)); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxBy() { + Observable> observable = maxBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithEmpty() { + Observable> observable = maxBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithComparator() { + Observable> observable = maxBy( + Observable.from("1", "2", "3", "4", "5", "6"), + new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6")); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } + + @Test + public void testMaxByWithComparatorAndEmpty() { + Observable> observable = maxBy( + Observable. empty(), new Func1() { + @Override + public Integer call(String t1) { + return Integer.parseInt(t1) % 2; + } + }, new Comparator() { + @Override + public int compare(Integer o1, Integer o2) { + return o2 - o1; + } + }); + + @SuppressWarnings("unchecked") + Observer> observer = (Observer>) mock(Observer.class); + + observable.subscribe(observer); + InOrder inOrder = inOrder(observer); + inOrder.verify(observer, times(1)).onNext(new ArrayList()); + inOrder.verify(observer, times(1)).onCompleted(); + inOrder.verifyNoMoreInteractions(); + } +} diff --git a/rxjava-core/src/test/java/rx/operators/OperationMinTest.java b/rxjava-core/src/test/java/rx/operators/OperationMinTest.java deleted file mode 100644 index 971baf1ddb..0000000000 --- a/rxjava-core/src/test/java/rx/operators/OperationMinTest.java +++ /dev/null @@ -1,182 +0,0 @@ -package rx.operators; - -import static org.mockito.Matchers.isA; -import static org.mockito.Mockito.inOrder; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.times; - -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Comparator; -import java.util.List; - -import org.junit.Test; -import org.mockito.InOrder; - -import rx.Observable; -import rx.Observer; -import rx.util.functions.Func1; - -public class OperationMinTest { - @Test - public void testMin() { - Observable observable = OperationMin.min(Observable.from(2, 3, - 1, 4)); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(1); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinWithEmpty() { - Observable observable = OperationMin.min(Observable - . empty()); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onError( - isA(IllegalArgumentException.class)); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinWithComparator() { - Observable observable = OperationMin.min( - Observable.from(2, 3, 1, 4), new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(4); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinWithComparatorAndEmpty() { - Observable observable = OperationMin.min( - Observable. empty(), new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer observer = (Observer) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onError( - isA(IllegalArgumentException.class)); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinBy() { - Observable> observable = OperationMin.minBy( - Observable.from("1", "2", "3", "4", "5", "6"), - new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(Arrays.asList("2", "4", "6")); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinByWithEmpty() { - Observable> observable = OperationMin.minBy( - Observable. empty(), new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new ArrayList()); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinByWithComparator() { - Observable> observable = OperationMin.minBy( - Observable.from("1", "2", "3", "4", "5", "6"), - new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(Arrays.asList("1", "3", "5")); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } - - @Test - public void testMinByWithComparatorAndEmpty() { - Observable> observable = OperationMin.minBy( - Observable. empty(), new Func1() { - @Override - public Integer call(String t1) { - return Integer.parseInt(t1) % 2; - } - }, new Comparator() { - @Override - public int compare(Integer o1, Integer o2) { - return o2 - o1; - } - }); - - @SuppressWarnings("unchecked") - Observer> observer = (Observer>) mock(Observer.class); - - observable.subscribe(observer); - InOrder inOrder = inOrder(observer); - inOrder.verify(observer, times(1)).onNext(new ArrayList()); - inOrder.verify(observer, times(1)).onCompleted(); - inOrder.verifyNoMoreInteractions(); - } -}