From a17085b1cd2ed255b49cb8832d8688a666bfe78c Mon Sep 17 00:00:00 2001 From: ccorti Date: Mon, 2 Oct 2017 00:40:03 +0200 Subject: [PATCH 1/4] RxJava Mathematical and Aggregate Operators --- rxjava/pom.xml | 11 + .../operators/RxAggregateOperatorsTest.java | 210 ++++++++++++++++++ .../RxMathematicalOperatorsTest.java | 139 ++++++++++++ 3 files changed, 360 insertions(+) create mode 100644 rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java create mode 100644 rxjava/src/test/java/com/baeldung/rxjava/operators/RxMathematicalOperatorsTest.java diff --git a/rxjava/pom.xml b/rxjava/pom.xml index bf5f073d8d30..8fec9d98fa5a 100644 --- a/rxjava/pom.xml +++ b/rxjava/pom.xml @@ -26,11 +26,22 @@ 2.1.3 + + io.reactivex + rxjava-math + 1.0.0 + + com.jayway.awaitility awaitility 1.7.0 + + io.reactivex.rxjava2 + rxjava + 2.1.1 + diff --git a/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java new file mode 100644 index 000000000000..82d65464d9f4 --- /dev/null +++ b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java @@ -0,0 +1,210 @@ +package com.baeldung.rxjava.operators; + +import org.junit.Test; +import rx.Observable; +import rx.observers.TestSubscriber; + +import java.util.*; + +public class RxAggregateOperatorsTest { + + @Test + public void givenTwoObservable_whenConcatenatingThem_thenSuccessfull() { + // given + List listOne = Arrays.asList(1, 2, 3, 4); + Observable observableOne = Observable.from(listOne); + + List listTwo = Arrays.asList(5, 6, 7, 8); + Observable observableTwo = Observable.from(listTwo); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable concatObservable = observableOne.concatWith(observableTwo); + + concatObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(8); + subscriber.assertValues(1, 2, 3, 4, 5, 6, 7, 8); + + } + + @Test + public void givenObservable_whenCounting_thenObtainingNumberOfElements() { + // given + List lettersList = Arrays.asList("A", "B", "C", "D", "E", "F", "G"); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable sourceObservable = Observable.from(lettersList) + .count(); + sourceObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(7); + } + + @Test + public void givenObservable_whenReducing_thenObtainingInvertedConcatenatedString() { + // given + List list = Arrays.asList("A", "B", "C", "D", "E", "F", "G"); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable reduceObservable = Observable.from(list) + .reduce((letter1, letter2) -> letter2 + letter1); + reduceObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue("GFEDCBA"); + } + + @Test + public void givenObservable_whenCollecting_thenObtainingASet() { + // given + List list = Arrays.asList("A", "B", "C", "B", "B", "A", "D"); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable reduceListObservable = Observable.from(list) + .collect(() -> new HashSet(), (set, item) -> set.add(item)); + reduceListObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValues(new HashSet(list)); + } + + @Test + public void givenObservable_whenUsingToList_thenObtainedAList() { + // given + Observable sourceObservable = Observable.range(1, 5); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable> listObservable = sourceObservable.toList(); + listObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(Arrays.asList(1, 2, 3, 4, 5)); + + } + + @Test + public void givenObservable_whenUsingToSortedList_thenObtainedAList() { + // given + Observable sourceObservable = Observable.range(10, 5); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable> listObservable = sourceObservable.toSortedList(); + listObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(Arrays.asList(10, 11, 12, 13, 14)); + } + + @Test + public void testToSortedListComparator() { + // given + Observable sourceObservable = Observable.range(10, 5); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable> listObservable = sourceObservable.toSortedList((int1, int2) -> int2 - int1); + listObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(Arrays.asList(14, 13, 12, 11, 10)); + + } + + @Test + public void testToMap() { + // given + Observable bookObservable = Observable.just(new Book("The North Water", 2016), new Book("Origin", 2017), new Book("Sleeping Beauties", 2017)); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable> mapObservable = bookObservable.toMap(Book::getTitle, Book::getYear, HashMap::new); + + mapObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(new HashMap() { + { + put("The North Water", 2016); + put("Origin", 2017); + put("Sleeping Beauties", 2017); + } + }); + } + + @Test + public void testToMultiMap() { + // given + Observable bookObservable = Observable.just(new Book("The North Water", 2016), new Book("Origin", 2017), new Book("Sleeping Beauties", 2017)); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable multiMapObservable = bookObservable.toMultimap(Book::getYear, Book::getTitle, () -> new HashMap(), (key) -> new ArrayList()); + + multiMapObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(new HashMap() { + { + put(2016, Arrays.asList("The North Water")); + put(2017, Arrays.asList("Origin", "Sleeping Beauties")); + } + }); + + } + + class Book { + private String title; + private Integer year; + + public Book(String title, Integer year) { + this.title = title; + this.year = year; + } + + public String getTitle() { + return title; + } + + public Integer getYear() { + return year; + } + } +} diff --git a/rxjava/src/test/java/com/baeldung/rxjava/operators/RxMathematicalOperatorsTest.java b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxMathematicalOperatorsTest.java new file mode 100644 index 000000000000..cd212a2e1883 --- /dev/null +++ b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxMathematicalOperatorsTest.java @@ -0,0 +1,139 @@ +package com.baeldung.rxjava.operators; + +import org.junit.Test; +import rx.Observable; +import rx.observables.MathObservable; +import rx.observers.TestSubscriber; + +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; + +public class RxMathematicalOperatorsTest { + + @Test + public void givenRangeNumericObservable_whenCalculatingAverage_ThenSuccessfull() { + // given + Observable sourceObservable = Observable.range(1, 20); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.averageInteger(sourceObservable) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(10); + } + + @Test + public void givenRangeNumericObservable_whenCalculatingSum_ThenSuccessfull() { + // given + Observable sourceObservable = Observable.range(1, 20); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.sumInteger(sourceObservable) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(210); + + } + + @Test + public void givenRangeNumericObservable_whenCalculatingMax_ThenSuccessfullObtainingMaxValue() { + // given + Observable sourceObservable = Observable.range(1, 20); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.max(sourceObservable) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(20); + } + + @Test + public void givenRangeNumericObservable_whenCalculatingMin_ThenSuccessfullObtainingMinValue() { + // given + Observable sourceObservable = Observable.range(1, 20); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.min(sourceObservable) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(1); + } + + @Test + public void givenItemObservable_whenCalculatingMaxWithComparator_ThenSuccessfullObtainingMaxItem() { + // given + Item five = new Item(5); + List list = Arrays.asList(new Item(1), new Item(2), new Item(3), new Item(4), five); + Observable itemObservable = Observable.from(list); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.from(itemObservable) + .max(Comparator.comparing(Item::getId)) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(five); + + } + + @Test + public void givenItemObservable_whenCalculatingMinWithComparator_ThenSuccessfullObtainingMinItem() { + // given + Item one = new Item(1); + List list = Arrays.asList(one, new Item(2), new Item(3), new Item(4), new Item(5)); + TestSubscriber subscriber = TestSubscriber.create(); + Observable itemObservable = Observable.from(list); + + // when + MathObservable.from(itemObservable) + .min(Comparator.comparing(Item::getId)) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(one); + + } + + class Item { + private Integer id; + + public Item(Integer id) { + this.id = id; + } + + public Integer getId() { + return id; + } + + } +} From dd47cf02520b1880a946108e0aadb0b824c4ff5b Mon Sep 17 00:00:00 2001 From: ccorti Date: Mon, 2 Oct 2017 00:42:30 +0200 Subject: [PATCH 2/4] Fixed test case names --- .../rxjava/operators/RxAggregateOperatorsTest.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java index 82d65464d9f4..1af41f795f02 100644 --- a/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java +++ b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java @@ -108,7 +108,7 @@ public void givenObservable_whenUsingToList_thenObtainedAList() { } @Test - public void givenObservable_whenUsingToSortedList_thenObtainedAList() { + public void givenObservable_whenUsingToSortedList_thenObtainedASortedList() { // given Observable sourceObservable = Observable.range(10, 5); TestSubscriber subscriber = TestSubscriber.create(); @@ -125,7 +125,7 @@ public void givenObservable_whenUsingToSortedList_thenObtainedAList() { } @Test - public void testToSortedListComparator() { + public void givenObservable_whenUsingToSortedListWithComparator_thenObtainedAnInverseSortedList() { // given Observable sourceObservable = Observable.range(10, 5); TestSubscriber subscriber = TestSubscriber.create(); @@ -143,7 +143,7 @@ public void testToSortedListComparator() { } @Test - public void testToMap() { + public void givenObservable_whenUsingToMap_thenObtainedAMap() { // given Observable bookObservable = Observable.just(new Book("The North Water", 2016), new Book("Origin", 2017), new Book("Sleeping Beauties", 2017)); TestSubscriber subscriber = TestSubscriber.create(); @@ -167,7 +167,7 @@ public void testToMap() { } @Test - public void testToMultiMap() { + public void givenObservable_whenUsingToMultiMap_thenObtainedAMultiMap() { // given Observable bookObservable = Observable.just(new Book("The North Water", 2016), new Book("Origin", 2017), new Book("Sleeping Beauties", 2017)); TestSubscriber subscriber = TestSubscriber.create(); From 9d110cc3e4d73a1ce128aca041c7de4ee0a9aa8d Mon Sep 17 00:00:00 2001 From: ccorti Date: Mon, 2 Oct 2017 00:54:29 +0200 Subject: [PATCH 3/4] Resolved merge conflict --- rxjava/pom.xml | 6 + .../operators/RxAggregateOperatorsTest.java | 210 ++++++++++++++++++ .../RxMathematicalOperatorsTest.java | 139 ++++++++++++ 3 files changed, 355 insertions(+) create mode 100644 rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java create mode 100644 rxjava/src/test/java/com/baeldung/rxjava/operators/RxMathematicalOperatorsTest.java diff --git a/rxjava/pom.xml b/rxjava/pom.xml index 783833243be8..0f950914ff34 100644 --- a/rxjava/pom.xml +++ b/rxjava/pom.xml @@ -25,6 +25,12 @@ 2.1.3 + + io.reactivex + rxjava-math + 1.0.0 + + com.jayway.awaitility awaitility diff --git a/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java new file mode 100644 index 000000000000..82d65464d9f4 --- /dev/null +++ b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java @@ -0,0 +1,210 @@ +package com.baeldung.rxjava.operators; + +import org.junit.Test; +import rx.Observable; +import rx.observers.TestSubscriber; + +import java.util.*; + +public class RxAggregateOperatorsTest { + + @Test + public void givenTwoObservable_whenConcatenatingThem_thenSuccessfull() { + // given + List listOne = Arrays.asList(1, 2, 3, 4); + Observable observableOne = Observable.from(listOne); + + List listTwo = Arrays.asList(5, 6, 7, 8); + Observable observableTwo = Observable.from(listTwo); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable concatObservable = observableOne.concatWith(observableTwo); + + concatObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(8); + subscriber.assertValues(1, 2, 3, 4, 5, 6, 7, 8); + + } + + @Test + public void givenObservable_whenCounting_thenObtainingNumberOfElements() { + // given + List lettersList = Arrays.asList("A", "B", "C", "D", "E", "F", "G"); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable sourceObservable = Observable.from(lettersList) + .count(); + sourceObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(7); + } + + @Test + public void givenObservable_whenReducing_thenObtainingInvertedConcatenatedString() { + // given + List list = Arrays.asList("A", "B", "C", "D", "E", "F", "G"); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable reduceObservable = Observable.from(list) + .reduce((letter1, letter2) -> letter2 + letter1); + reduceObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue("GFEDCBA"); + } + + @Test + public void givenObservable_whenCollecting_thenObtainingASet() { + // given + List list = Arrays.asList("A", "B", "C", "B", "B", "A", "D"); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable reduceListObservable = Observable.from(list) + .collect(() -> new HashSet(), (set, item) -> set.add(item)); + reduceListObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValues(new HashSet(list)); + } + + @Test + public void givenObservable_whenUsingToList_thenObtainedAList() { + // given + Observable sourceObservable = Observable.range(1, 5); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable> listObservable = sourceObservable.toList(); + listObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(Arrays.asList(1, 2, 3, 4, 5)); + + } + + @Test + public void givenObservable_whenUsingToSortedList_thenObtainedAList() { + // given + Observable sourceObservable = Observable.range(10, 5); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable> listObservable = sourceObservable.toSortedList(); + listObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(Arrays.asList(10, 11, 12, 13, 14)); + } + + @Test + public void testToSortedListComparator() { + // given + Observable sourceObservable = Observable.range(10, 5); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable> listObservable = sourceObservable.toSortedList((int1, int2) -> int2 - int1); + listObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(Arrays.asList(14, 13, 12, 11, 10)); + + } + + @Test + public void testToMap() { + // given + Observable bookObservable = Observable.just(new Book("The North Water", 2016), new Book("Origin", 2017), new Book("Sleeping Beauties", 2017)); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable> mapObservable = bookObservable.toMap(Book::getTitle, Book::getYear, HashMap::new); + + mapObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(new HashMap() { + { + put("The North Water", 2016); + put("Origin", 2017); + put("Sleeping Beauties", 2017); + } + }); + } + + @Test + public void testToMultiMap() { + // given + Observable bookObservable = Observable.just(new Book("The North Water", 2016), new Book("Origin", 2017), new Book("Sleeping Beauties", 2017)); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + Observable multiMapObservable = bookObservable.toMultimap(Book::getYear, Book::getTitle, () -> new HashMap(), (key) -> new ArrayList()); + + multiMapObservable.subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(new HashMap() { + { + put(2016, Arrays.asList("The North Water")); + put(2017, Arrays.asList("Origin", "Sleeping Beauties")); + } + }); + + } + + class Book { + private String title; + private Integer year; + + public Book(String title, Integer year) { + this.title = title; + this.year = year; + } + + public String getTitle() { + return title; + } + + public Integer getYear() { + return year; + } + } +} diff --git a/rxjava/src/test/java/com/baeldung/rxjava/operators/RxMathematicalOperatorsTest.java b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxMathematicalOperatorsTest.java new file mode 100644 index 000000000000..cd212a2e1883 --- /dev/null +++ b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxMathematicalOperatorsTest.java @@ -0,0 +1,139 @@ +package com.baeldung.rxjava.operators; + +import org.junit.Test; +import rx.Observable; +import rx.observables.MathObservable; +import rx.observers.TestSubscriber; + +import java.util.Arrays; +import java.util.Comparator; +import java.util.List; + +public class RxMathematicalOperatorsTest { + + @Test + public void givenRangeNumericObservable_whenCalculatingAverage_ThenSuccessfull() { + // given + Observable sourceObservable = Observable.range(1, 20); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.averageInteger(sourceObservable) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(10); + } + + @Test + public void givenRangeNumericObservable_whenCalculatingSum_ThenSuccessfull() { + // given + Observable sourceObservable = Observable.range(1, 20); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.sumInteger(sourceObservable) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(210); + + } + + @Test + public void givenRangeNumericObservable_whenCalculatingMax_ThenSuccessfullObtainingMaxValue() { + // given + Observable sourceObservable = Observable.range(1, 20); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.max(sourceObservable) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(20); + } + + @Test + public void givenRangeNumericObservable_whenCalculatingMin_ThenSuccessfullObtainingMinValue() { + // given + Observable sourceObservable = Observable.range(1, 20); + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.min(sourceObservable) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(1); + } + + @Test + public void givenItemObservable_whenCalculatingMaxWithComparator_ThenSuccessfullObtainingMaxItem() { + // given + Item five = new Item(5); + List list = Arrays.asList(new Item(1), new Item(2), new Item(3), new Item(4), five); + Observable itemObservable = Observable.from(list); + + TestSubscriber subscriber = TestSubscriber.create(); + + // when + MathObservable.from(itemObservable) + .max(Comparator.comparing(Item::getId)) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(five); + + } + + @Test + public void givenItemObservable_whenCalculatingMinWithComparator_ThenSuccessfullObtainingMinItem() { + // given + Item one = new Item(1); + List list = Arrays.asList(one, new Item(2), new Item(3), new Item(4), new Item(5)); + TestSubscriber subscriber = TestSubscriber.create(); + Observable itemObservable = Observable.from(list); + + // when + MathObservable.from(itemObservable) + .min(Comparator.comparing(Item::getId)) + .subscribe(subscriber); + + // then + subscriber.assertCompleted(); + subscriber.assertNoErrors(); + subscriber.assertValueCount(1); + subscriber.assertValue(one); + + } + + class Item { + private Integer id; + + public Item(Integer id) { + this.id = id; + } + + public Integer getId() { + return id; + } + + } +} From 80acec512cbb08f20f4f8045aaaffbccef812782 Mon Sep 17 00:00:00 2001 From: ccorti Date: Mon, 2 Oct 2017 00:42:30 +0200 Subject: [PATCH 4/4] Fixed test case names --- .../rxjava/operators/RxAggregateOperatorsTest.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java index 82d65464d9f4..1af41f795f02 100644 --- a/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java +++ b/rxjava/src/test/java/com/baeldung/rxjava/operators/RxAggregateOperatorsTest.java @@ -108,7 +108,7 @@ public void givenObservable_whenUsingToList_thenObtainedAList() { } @Test - public void givenObservable_whenUsingToSortedList_thenObtainedAList() { + public void givenObservable_whenUsingToSortedList_thenObtainedASortedList() { // given Observable sourceObservable = Observable.range(10, 5); TestSubscriber subscriber = TestSubscriber.create(); @@ -125,7 +125,7 @@ public void givenObservable_whenUsingToSortedList_thenObtainedAList() { } @Test - public void testToSortedListComparator() { + public void givenObservable_whenUsingToSortedListWithComparator_thenObtainedAnInverseSortedList() { // given Observable sourceObservable = Observable.range(10, 5); TestSubscriber subscriber = TestSubscriber.create(); @@ -143,7 +143,7 @@ public void testToSortedListComparator() { } @Test - public void testToMap() { + public void givenObservable_whenUsingToMap_thenObtainedAMap() { // given Observable bookObservable = Observable.just(new Book("The North Water", 2016), new Book("Origin", 2017), new Book("Sleeping Beauties", 2017)); TestSubscriber subscriber = TestSubscriber.create(); @@ -167,7 +167,7 @@ public void testToMap() { } @Test - public void testToMultiMap() { + public void givenObservable_whenUsingToMultiMap_thenObtainedAMultiMap() { // given Observable bookObservable = Observable.just(new Book("The North Water", 2016), new Book("Origin", 2017), new Book("Sleeping Beauties", 2017)); TestSubscriber subscriber = TestSubscriber.create();