JAVA-11499 move rxjava* modules to new rxjava-modules (#12342)

* JAVA-11499 move rxjava* modules to new rxjava-modules

* JAVA-11499 addressed PR comments

rxjava-modules/rxjava-observables/README.md

@@ -0,0 +1,11 @@
+## RxJava Observables
+ 
+ This module contains articles about RxJava Observables
+ 
+### Related Articles:
+
+- [Combining Observables in RxJava](https://www.baeldung.com/rxjava-combine-observables)
+- [RxJava One Observable, Multiple Subscribers](https://www.baeldung.com/rxjava-multiple-subscribers-observable)
+- [RxJava StringObservable](https://www.baeldung.com/rxjava-string)
+- [Filtering Observables in RxJava](https://www.baeldung.com/rxjava-filtering)
+ 

rxjava-modules/rxjava-observables/pom.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>rxjava-observables</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <name>rxjava-observables</name>
+    <parent>
+        <groupId>com.baeldung.rxjava-modules</groupId>
+        <artifactId>rxjava-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+</project>

rxjava-modules/rxjava-observables/src/main/java/com/baeldung/rxjava/MultipleSubscribersColdObs.java

@@ -0,0 +1,59 @@
+package com.baeldung.rxjava;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import rx.Observable;
+import rx.Subscription;
+import rx.observables.ConnectableObservable;
+import rx.subscriptions.Subscriptions;
+
+public class MultipleSubscribersColdObs {
+    private static final Logger LOGGER = LoggerFactory.getLogger(MultipleSubscribersColdObs.class);
+
+    public static void main(String[] args) throws InterruptedException {
+        defaultBehaviour();
+        // subscribeBeforeConnect();
+
+    }
+
+    private static void defaultBehaviour() {
+        Observable obs = getObservable();
+
+        LOGGER.info("Subscribing");
+        Subscription s1 = obs.subscribe(i -> LOGGER.info("subscriber#1 is printing " + i));
+        Subscription s2 = obs.subscribe(i -> LOGGER.info("subscriber#2 is printing " + i));
+
+        s1.unsubscribe();
+        s2.unsubscribe();
+    }
+
+    private static void subscribeBeforeConnect() throws InterruptedException {
+        ConnectableObservable obs = getObservable().publish();
+
+        LOGGER.info("Subscribing");
+        obs.subscribe(i -> LOGGER.info("subscriber #1 is printing " + i));
+        obs.subscribe(i -> LOGGER.info("subscriber #2 is printing " + i));
+        Thread.sleep(1000);
+        LOGGER.info("Connecting");
+        Subscription s = obs.connect();
+        s.unsubscribe();
+
+    }
+
+    private static Observable getObservable() {
+        return Observable.create(subscriber -> {
+            subscriber.onNext(gettingValue(1));
+            subscriber.onNext(gettingValue(2));
+
+            subscriber.add(Subscriptions.create(() -> {
+                LOGGER.info("Clear resources");
+            }));
+        });
+    }
+
+    private static Integer gettingValue(int i) {
+        LOGGER.info("Getting " + i);
+        return i;
+    }
+}

rxjava-modules/rxjava-observables/src/main/java/com/baeldung/rxjava/MultipleSubscribersHotObs.java

@@ -0,0 +1,152 @@
+package com.baeldung.rxjava;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.lang.reflect.InvocationTargetException;
+
+import javax.swing.JFrame;
+import rx.Observable;
+import rx.Subscription;
+import rx.observables.ConnectableObservable;
+import rx.subscriptions.Subscriptions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MultipleSubscribersHotObs {
+    private static final Logger LOGGER = LoggerFactory.getLogger(MultipleSubscribersHotObs.class);
+    private static JFrame frame;
+
+    public static void main(String[] args) throws InterruptedException, InvocationTargetException {
+
+        javax.swing.SwingUtilities.invokeAndWait(new Runnable() {
+            public void run() {
+                createAndShowGUI();
+            }
+        });
+
+        defaultBehaviour();
+        // subscribeBeforeConnect();
+        // connectBeforeSubscribe();
+        // autoConnectAndSubscribe();
+        // refCountAndSubscribe();
+    }
+
+    private static void createAndShowGUI() {
+        frame = new JFrame("Hot Observable Demo");
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        frame.getContentPane().setBackground(Color.GRAY);
+        frame.setPreferredSize(new Dimension(500, 500));
+        frame.pack();
+        frame.setVisible(true);
+    }
+
+    public static void defaultBehaviour() throws InterruptedException {
+        Observable obs = getObservable();
+
+        LOGGER.info("subscribing #1");
+        Subscription subscription1 = obs.subscribe((i) -> LOGGER.info("subscriber#1 is printing x-coordinate " + i));
+
+        Thread.sleep(1000);
+        LOGGER.info("subscribing #2");
+        Subscription subscription2 = obs.subscribe((i) -> LOGGER.info("subscriber#2 is printing x-coordinate " + i));
+        Thread.sleep(1000);
+        LOGGER.info("unsubscribe#1");
+        subscription1.unsubscribe();
+        Thread.sleep(1000);
+        LOGGER.info("unsubscribe#2");
+        subscription2.unsubscribe();
+    }
+
+    public static void subscribeBeforeConnect() throws InterruptedException {
+
+        ConnectableObservable obs = getObservable().publish();
+
+        LOGGER.info("subscribing #1");
+        Subscription subscription1 = obs.subscribe((i) -> LOGGER.info("subscriber#1 is printing x-coordinate " + i));
+        Thread.sleep(1000);
+        LOGGER.info("subscribing #2");
+        Subscription subscription2 = obs.subscribe((i) -> LOGGER.info("subscriber#2 is printing x-coordinate " + i));
+        Thread.sleep(1000);
+        LOGGER.info("connecting:");
+        Subscription s = obs.connect();
+        Thread.sleep(1000);
+        LOGGER.info("unsubscribe connected");
+        s.unsubscribe();
+
+    }
+
+    public static void connectBeforeSubscribe() throws InterruptedException {
+
+        ConnectableObservable obs = getObservable().doOnNext(x -> LOGGER.info("saving " + x)).publish();
+        LOGGER.info("connecting:");
+        Subscription s = obs.connect();
+        Thread.sleep(1000);
+        LOGGER.info("subscribing #1");
+        obs.subscribe((i) -> LOGGER.info("subscriber#1 is printing x-coordinate " + i));
+        Thread.sleep(1000);
+        LOGGER.info("subscribing #2");
+        obs.subscribe((i) -> LOGGER.info("subscriber#2 is printing x-coordinate " + i));
+        Thread.sleep(1000);
+        s.unsubscribe();
+
+    }
+
+    public static void autoConnectAndSubscribe() throws InterruptedException {
+        Observable obs = getObservable().doOnNext(x -> LOGGER.info("saving " + x)).publish().autoConnect();
+
+        LOGGER.info("autoconnect()");
+        Thread.sleep(1000);
+        LOGGER.info("subscribing #1");
+        Subscription s1 = obs.subscribe((i) -> LOGGER.info("subscriber#1 is printing x-coordinate " + i));
+        Thread.sleep(1000);
+        LOGGER.info("subscribing #2");
+        Subscription s2 = obs.subscribe((i) -> LOGGER.info("subscriber#2 is printing x-coordinate " + i));
+
+        Thread.sleep(1000);
+        LOGGER.info("unsubscribe 1");
+        s1.unsubscribe();
+        Thread.sleep(1000);
+        LOGGER.info("unsubscribe 2");
+        s2.unsubscribe();
+    }
+
+    public static void refCountAndSubscribe() throws InterruptedException {
+        Observable obs = getObservable().doOnNext(x -> LOGGER.info("saving " + x)).publish().refCount();
+
+        LOGGER.info("refcount()");
+        Thread.sleep(1000);
+        LOGGER.info("subscribing #1");
+        Subscription subscription1 = obs.subscribe((i) -> LOGGER.info("subscriber#1 is printing x-coordinate " + i));
+        Thread.sleep(1000);
+        LOGGER.info("subscribing #2");
+        Subscription subscription2 = obs.subscribe((i) -> LOGGER.info("subscriber#2 is printing x-coordinate " + i));
+
+        Thread.sleep(1000);
+        LOGGER.info("unsubscribe#1");
+        subscription1.unsubscribe();
+        Thread.sleep(1000);
+        LOGGER.info("unsubscribe#2");
+        subscription2.unsubscribe();
+
+    }
+
+    private static Observable getObservable() {
+        return Observable.create(subscriber -> {
+            frame.addMouseListener(new MouseAdapter() {
+                @Override
+                public void mouseClicked(MouseEvent e) {
+                    subscriber.onNext(e.getX());
+                }
+            });
+            subscriber.add(Subscriptions.create(() -> {
+                LOGGER.info("Clear resources");
+                for (MouseListener listener : frame.getListeners(MouseListener.class)) {
+                    frame.removeMouseListener(listener);
+                }
+            }));
+        });
+    }
+}

rxjava-modules/rxjava-observables/src/test/java/com/baeldung/rxjava/combine/ObservableCombineUnitTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.rxjava.combine;
+
+import org.junit.Test;
+import rx.Observable;
+import rx.observers.TestSubscriber;
+
+import java.util.concurrent.TimeUnit;
+
+import static java.util.Arrays.asList;
+
+public class ObservableCombineUnitTest {
+
+    @Test
+    public void givenTwoObservables_whenMerged_shouldEmitCombinedResults() {
+        TestSubscriber<String> testSubscriber = new TestSubscriber<>();
+
+        Observable.merge(
+          Observable.from(asList("Hello", "World")),
+          Observable.from(asList("I love", "RxJava"))
+        ).subscribe(testSubscriber);
+
+        testSubscriber.assertValues("Hello", "World", "I love", "RxJava");
+    }
+
+    @Test
+    public void givenTwoObservables_whenZipped_thenReturnCombinedResults() {
+        TestSubscriber<String> testSubscriber = new TestSubscriber<>();
+
+        Observable.zip(
+          Observable.from(asList("Simple", "Moderate", "Complex")),
+          Observable.from(asList("Solutions", "Success", "Hierarchy")),
+          (str1, str2) -> String.format("%s %s", str1, str2))
+          .subscribe(testSubscriber);
+
+        testSubscriber.assertValues("Simple Solutions", "Moderate Success", "Complex Hierarchy");
+    }
+
+    @Test
+    public void givenMutipleObservablesOneThrows_whenMerged_thenCombineBeforePropagatingError() {
+        TestSubscriber<String> testSubscriber = new TestSubscriber<>();
+
+        Observable.mergeDelayError(
+          Observable.from(asList("hello", "world")),
+          Observable.error(new RuntimeException("Some exception")),
+          Observable.from(asList("rxjava"))
+        ).subscribe(testSubscriber);
+
+        testSubscriber.assertValues("hello", "world", "rxjava");
+        testSubscriber.assertError(RuntimeException.class);
+    }
+
+    @Test
+    public void givenAStream_whenZippedWithInterval_shouldDelayStreamEmmission() {
+        TestSubscriber<String> testSubscriber = new TestSubscriber<>();
+
+        Observable<String> data = Observable.just("one", "two", "three", "four", "five");
+        Observable<Long> interval = Observable.interval(1L, TimeUnit.SECONDS);
+
+        Observable
+          .zip(data, interval, (strData, tick) -> String.format("[%d]=%s", tick, strData))
+          .toBlocking().subscribe(testSubscriber);
+
+        testSubscriber.assertCompleted();
+        testSubscriber.assertValueCount(5);
+        testSubscriber.assertValues("[0]=one", "[1]=two", "[2]=three", "[3]=four", "[4]=five");
+    }
+}

rxjava-modules/rxjava-observables/src/test/java/com/baeldung/rxjava/filters/RxJavaFilterOperatorsIntegrationTest.java

@@ -0,0 +1,202 @@
+package com.baeldung.rxjava.filters;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.observers.TestSubscriber;
+
+public class RxJavaFilterOperatorsIntegrationTest {
+
+    @Test
+    public void givenRangeObservable_whenFilteringItems_thenOddItemsAreFiltered() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.filter(i -> i % 2 != 0);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(5);
+        subscriber.assertValues(1, 3, 5, 7, 9);
+    }
+
+    @Test
+    public void givenRangeObservable_whenFilteringWithTake_thenOnlyFirstThreeItemsAreEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.take(3);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(3);
+        subscriber.assertValues(1, 2, 3);
+    }
+
+    @Test
+    public void givenObservable_whenFilteringWithTakeWhile_thenItemsEmittedUntilConditionIsVerified() {
+
+        Observable<Integer> sourceObservable = Observable.just(1, 2, 3, 4, 3, 2, 1);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.takeWhile(i -> i < 4);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(3);
+        subscriber.assertValues(1, 2, 3);
+    }
+
+    @Test
+    public void givenRangeObservable_whenFilteringWithTakeFirst_thenOnlyFirstItemIsEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.just(1, 2, 3, 4, 5, 7, 6);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.takeFirst(x -> x > 5);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValue(7);
+    }
+
+    @Test
+    public void givenRangeObservable_whenFilteringWithFirst_thenOnlyFirstThreeItemsAreEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.first();
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValue(1);
+    }
+
+    @Test
+    public void givenEmptyObservable_whenFilteringWithFirstOrDefault_thenDefaultValue() {
+
+        Observable<Integer> sourceObservable = Observable.empty();
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.firstOrDefault(-1);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValue(-1);
+    }
+
+    @Test
+    public void givenRangeObservable_whenFilteringWithTakeLast_thenLastThreeItemAreEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.takeLast(3);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(3);
+        subscriber.assertValues(8, 9, 10);
+    }
+
+    @Test
+    public void givenRangeObservable_whenFilteringWithLast_thenOnlyLastItemIsEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.last(i -> i % 2 != 0);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValue(9);
+    }
+
+    @Test
+    public void givenRangeObservable_whenFilteringWithLastAndDefault_thenOnlyDefaultIsEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.lastOrDefault(-1, i -> i > 10);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValue(-1);
+    }
+
+    @Test
+    public void givenObservable_whenTakingElementAt_thenItemAtSpecifiedIndexIsEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.just(1, 2, 3, 5, 7, 11);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.elementAt(4);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValue(7);
+    }
+
+    @Test
+    public void givenObservable_whenTakingElementAtOrDefault_thenDefaultIsReturned() {
+
+        Observable<Integer> sourceObservable = Observable.just(1, 2, 3, 5, 7, 11);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.elementAtOrDefault(7, -1);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValue(-1);
+    }
+
+    @Test
+    public void givenMixedTypeObservable_whenFilteringByType_thenOnlyNumbersAreEmitted() {
+
+        Observable sourceObservable = Observable.just(1, "two", 3, "five", 7, 11);
+        TestSubscriber subscriber = new TestSubscriber();
+
+        Observable filteredObservable = sourceObservable.ofType(String.class);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(2);
+        subscriber.assertValues("two", "five");
+
+    }
+}

rxjava-modules/rxjava-observables/src/test/java/com/baeldung/rxjava/filters/RxJavaSkipOperatorsIntegrationTest.java

@@ -0,0 +1,105 @@
+package com.baeldung.rxjava.filters;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.observers.TestSubscriber;
+
+public class RxJavaSkipOperatorsIntegrationTest {
+
+    @Test
+    public void givenRangeObservable_whenSkipping_thenFirstFourItemsAreSkipped() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.skip(4);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(6);
+        subscriber.assertValues(5, 6, 7, 8, 9, 10);
+    }
+
+    @Test
+    public void givenObservable_whenSkippingWhile_thenFirstItemsAreSkipped() {
+
+        Observable<Integer> sourceObservable = Observable.just(1, 2, 3, 4, 5, 4, 3, 2, 1);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.skipWhile(i -> i < 4);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(6);
+        subscriber.assertValues(4, 5, 4, 3, 2, 1);
+    }
+
+    @Test
+    public void givenRangeObservable_whenSkippingLast_thenLastFiveItemsAreSkipped() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = sourceObservable.skipLast(5);
+
+        filteredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(5);
+        subscriber.assertValues(1, 2, 3, 4, 5);
+    }
+
+    @Test
+    public void givenObservable_whenFilteringDistinct_thenOnlyDistinctValuesAreEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.just(1, 1, 2, 2, 1, 3, 3, 1);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> distinctObservable = sourceObservable.distinct();
+
+        distinctObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(3);
+        subscriber.assertValues(1, 2, 3);
+    }
+
+    @Test
+    public void givenObservable_whenFilteringDistinctUntilChanged_thenOnlyDistinctConsecutiveItemsAreEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.just(1, 1, 2, 2, 1, 3, 3, 1);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> distinctObservable = sourceObservable.distinctUntilChanged();
+
+        distinctObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(5);
+        subscriber.assertValues(1, 2, 1, 3, 1);
+    }
+
+    @Test
+    public void givenRangeObservable_whenIgnoringElements_thenOnlyDistinctConsecutiveItemsAreEmitted() {
+
+        Observable<Integer> sourceObservable = Observable.range(1, 10);
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> ignoredObservable = sourceObservable.ignoreElements();
+
+        ignoredObservable.subscribe(subscriber);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(0);
+        subscriber.assertNoValues();
+    }
+}

rxjava-modules/rxjava-observables/src/test/java/com/baeldung/rxjava/filters/RxJavaTimeFilteringOperatorsIntegrationTest.java

@@ -0,0 +1,221 @@
+package com.baeldung.rxjava.filters;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.observers.TestSubscriber;
+import rx.schedulers.TestScheduler;
+
+public class RxJavaTimeFilteringOperatorsIntegrationTest {
+
+    @Test
+    public void givenTimedObservable_whenSampling_thenOnlySampleItemsAreEmitted() {
+
+        TestScheduler testScheduler = new TestScheduler();
+
+        Observable<Integer> timedObservable =
+                Observable.just(1, 2, 3, 4, 5, 6)
+                        .zipWith(
+                                Observable.interval(0, 1, TimeUnit.SECONDS, testScheduler),
+                                (item, time) -> item
+                        );
+
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> sampledObservable =
+                timedObservable.sample(2500L, TimeUnit.MILLISECONDS, testScheduler);
+
+        sampledObservable.subscribe(subscriber);
+
+        testScheduler.advanceTimeBy(7, TimeUnit.SECONDS);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValues(3, 5, 6);
+    }
+
+    @Test
+    public void givenTimedObservable_whenThrottlingLast_thenThrottleLastItemsAreEmitted() {
+
+        TestScheduler testScheduler = new TestScheduler();
+
+        Observable<Integer> timedObservable =
+                Observable.just(1, 2, 3, 4, 5, 6)
+                        .zipWith(
+                                Observable.interval(0, 1, TimeUnit.SECONDS, testScheduler),
+                                (item, time) -> item
+                        );
+
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = timedObservable.throttleLast(3100L, TimeUnit.MILLISECONDS, testScheduler);
+
+        filteredObservable.subscribe(subscriber);
+
+        testScheduler.advanceTimeBy(7, TimeUnit.SECONDS);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValues(4, 6);
+    }
+
+    @Test
+    public void givenRangeObservable_whenThrottlingFirst_thenThrottledFirstItemsAreEmitted() {
+
+        TestScheduler testScheduler = new TestScheduler();
+
+        Observable<Integer> timedObservable =
+                Observable.just(1, 2, 3, 4, 5, 6)
+                        .zipWith(
+                                Observable.interval(0, 1, TimeUnit.SECONDS, testScheduler),
+                                (item, time) -> item
+                        );
+
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable =
+                timedObservable.throttleFirst(4100L, TimeUnit.MILLISECONDS, testScheduler);
+
+        filteredObservable.subscribe(subscriber);
+
+        testScheduler.advanceTimeBy(7, TimeUnit.SECONDS);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValues(1, 6);
+    }
+
+    @Test
+    public void givenTimedObservable_whenThrottlingWithTimeout_thenLastItemIsEmitted() {
+
+        TestScheduler testScheduler = new TestScheduler();
+
+        Observable<Integer> timedObservable =
+                Observable.just(1, 2, 3, 4, 5, 6)
+                        .zipWith(
+                                Observable.interval(0, 1, TimeUnit.SECONDS, testScheduler),
+                                (item, time) -> item
+                        );
+
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = timedObservable.throttleWithTimeout(2000L, TimeUnit.MILLISECONDS, testScheduler);
+
+        filteredObservable.subscribe(subscriber);
+
+        testScheduler.advanceTimeBy(7, TimeUnit.SECONDS);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValue(6);
+    }
+
+    @Test
+    public void givenTimedObservable_whenDebounceOperatorIsApplied_thenLastItemIsEmitted() {
+
+        TestScheduler testScheduler = new TestScheduler();
+
+        Observable<Integer> timedObservable =
+                Observable.just(1, 2, 3, 4, 5, 6)
+                        .zipWith(
+                                Observable.interval(0, 1, TimeUnit.SECONDS, testScheduler),
+                                (item, time) -> item
+                        );
+
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = timedObservable.debounce(2000L, TimeUnit.MILLISECONDS, testScheduler);
+
+        filteredObservable.subscribe(subscriber);
+
+        testScheduler.advanceTimeBy(7, TimeUnit.SECONDS);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValue(6);
+    }
+
+    @Test
+    public void givenTimedObservable_whenUsingTimeout_thenTimeOutException() {
+
+        TestScheduler testScheduler = new TestScheduler();
+
+        Observable<Integer> timedObservable =
+                Observable.just(1, 2, 3, 4, 5, 6)
+                        .zipWith(
+                                Observable.interval(0, 1, TimeUnit.SECONDS, testScheduler),
+                                (item, time) -> item
+                        );
+
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = timedObservable.timeout(500L, TimeUnit.MILLISECONDS, testScheduler);
+
+        filteredObservable.subscribe(subscriber);
+
+        testScheduler.advanceTimeBy(7, TimeUnit.SECONDS);
+
+        subscriber.assertError(TimeoutException.class);
+        subscriber.assertValues(1);
+    }
+
+    @Test
+    public void givenObservable_whenSkippingUntil_thenItemsAreSkippedUntilSecondObservableEmitsItems() {
+
+        TestScheduler testScheduler = new TestScheduler();
+
+        Observable<Integer> timedObservable =
+                Observable.just(1, 2, 3, 4, 5, 6)
+                        .zipWith(
+                                Observable.interval(0, 1, TimeUnit.SECONDS, testScheduler),
+                                (item, time) -> item
+                        );
+
+
+        Observable<Integer> delayedObservable = Observable.just(1)
+                .delay(3000, TimeUnit.MILLISECONDS, testScheduler);
+
+        TestSubscriber<Integer> subscriber = new TestSubscriber();
+
+        Observable<Integer> filteredObservable = timedObservable.skipUntil(delayedObservable);
+
+        filteredObservable.subscribe(subscriber);
+
+        testScheduler.advanceTimeBy(7, TimeUnit.SECONDS);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValues(4, 5, 6);
+    }
+
+    @Test
+    public void givenObservable_whenSkippingWhile_thenItemsAreEmittedUntilSecondObservableEmitsItems() {
+
+        TestScheduler testScheduler = new TestScheduler();
+
+        Observable<Integer> timedObservable =
+                Observable.just(1, 2, 3, 4, 5, 6)
+                        .zipWith(
+                                Observable.interval(0, 1, TimeUnit.SECONDS, testScheduler),
+                                (item, time) -> item
+                        );
+
+        TestSubscriber subscriber = new TestSubscriber();
+
+        Observable<Integer> delayedObservable = Observable.just(1)
+                .delay(3000, TimeUnit.MILLISECONDS, testScheduler);
+
+        Observable<Integer> filteredObservable = timedObservable.takeUntil(delayedObservable);
+
+        filteredObservable.subscribe(subscriber);
+
+        testScheduler.advanceTimeBy(7, TimeUnit.SECONDS);
+
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValues(1, 2, 3);
+    }
+}

rxjava-modules/rxjava-observables/src/test/java/com/baeldung/rxjava/operators/RxStringOperatorsUnitTest.java

@@ -0,0 +1,145 @@
+package com.baeldung.rxjava.operators;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import rx.Observable;
+import rx.observables.StringObservable;
+import rx.observers.TestSubscriber;
+
+
+public class RxStringOperatorsUnitTest
+{
+
+    @Test
+    public void givenStringObservable_whenFromInputStream_ThenSuccessfull()
+    {
+        //given
+        ByteArrayInputStream is = new ByteArrayInputStream("Lorem ipsum loream, Lorem ipsum lore".getBytes(StandardCharsets.UTF_8));
+        TestSubscriber<String> subscriber = TestSubscriber.create();
+
+        // when
+        StringObservable.decode(StringObservable.from(is), StandardCharsets.UTF_8)
+            .subscribe(subscriber);
+
+        // then
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValues("Lorem ipsum loream, Lorem ipsum lore");
+    }
+    @Test
+    public void givenStringObservable_whenEncodingString_ThenSuccessfullObtainingByteStream()
+    {
+        //given
+        Observable<String> sourceObservable = Observable.just("Lorem ipsum loream");
+        TestSubscriber<byte[]> subscriber = TestSubscriber.create();
+
+        // when
+        StringObservable.encode(sourceObservable, StandardCharsets.UTF_8)
+            .subscribe(subscriber);
+
+        // then
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.getOnNextEvents()
+            .stream()
+            .forEach(bytes -> Assert.assertTrue(Arrays.equals(bytes, "Lorem ipsum loream".getBytes(StandardCharsets.UTF_8))));
+    }
+
+    @Test
+    public void givenStringObservable_whenConcatenatingStrings_ThenSuccessfullObtainingSingleString()
+    {
+        //given
+        Observable<String> sourceObservable = Observable.just("Lorem ipsum loream","Lorem ipsum lore");
+        TestSubscriber<String> subscriber = TestSubscriber.create();
+
+        // when
+        StringObservable.stringConcat(sourceObservable)
+            .subscribe(subscriber);
+
+        // then
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValues("Lorem ipsum loreamLorem ipsum lore");
+    }
+
+
+    @Test
+    public void givenStringObservable_whenDecodingByteArray_ThenSuccessfullObtainingStringStream()
+    {
+        //given
+        Observable<byte[]> sourceObservable = Observable.just("Lorem ipsum loream".getBytes(StandardCharsets.UTF_8));
+        TestSubscriber<String> subscriber = TestSubscriber.create();
+
+        // when
+        StringObservable.decode(sourceObservable, StandardCharsets.UTF_8)
+            .subscribe(subscriber);
+
+        // then
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValues("Lorem ipsum loream");
+    }
+
+    @Test
+    public void givenStringObservable_whenStringSplitted_ThenSuccessfullObtainingStringsStream()
+    {
+        //given
+        Observable<String> sourceObservable = Observable.just("Lorem ipsum loream,Lorem ipsum lore");
+        TestSubscriber<String> subscriber = TestSubscriber.create();
+
+        // when
+        StringObservable.split(sourceObservable,",")
+            .subscribe(subscriber);
+
+        // then
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(2);
+        subscriber.assertValues("Lorem ipsum loream", "Lorem ipsum lore");
+    }
+
+    @Test
+    public void givenStringObservable_whenSplittingByLine_ThenSuccessfullObtainingStringsStream() {
+        //given
+        Observable<String> sourceObservable = Observable.just("Lorem ipsum loream\nLorem ipsum lore");
+        TestSubscriber<String> subscriber = TestSubscriber.create();
+
+        // when
+        StringObservable.byLine(sourceObservable)
+            .subscribe(subscriber);
+
+        // then
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(2);
+        subscriber.assertValues("Lorem ipsum loream", "Lorem ipsum lore");
+    }
+
+
+    @Test
+    public void givenStringObservable_whenJoiningStrings_ThenSuccessfullObtainingSingleString() {
+        //given
+        Observable<String> sourceObservable = Observable.just("Lorem ipsum loream","Lorem ipsum lore");
+        TestSubscriber<String> subscriber = TestSubscriber.create();
+
+        // when
+        StringObservable.join(sourceObservable,",")
+            .subscribe(subscriber);
+
+        // then
+        subscriber.assertCompleted();
+        subscriber.assertNoErrors();
+        subscriber.assertValueCount(1);
+        subscriber.assertValues("Lorem ipsum loream,Lorem ipsum lore");
+    }
+
+}