Merge branch 'masterupstream' into beforeAfterAnnotationsJunit

apache-opennlp/pom.xml

@@ -0,0 +1,32 @@
+<?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>
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+    <artifactId>apache-opennlp</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.opennlp</groupId>
+            <artifactId>opennlp-tools</artifactId>
+            <version>1.8.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.9.0</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

apache-opennlp/src/test/java/com/baeldung/apache/opennlp/ChunkerTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.apache.opennlp;
+
+import java.io.FileInputStream;
+import java.io.InputStream;
+import opennlp.tools.chunker.ChunkerME;
+import opennlp.tools.chunker.ChunkerModel;
+import opennlp.tools.postag.POSModel;
+import opennlp.tools.postag.POSTaggerME;
+import opennlp.tools.tokenize.SimpleTokenizer;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class ChunkerTest {
+
+    @Test
+    public void givenChunkerModel_whenChunk_thenChunksAreDetected() throws Exception {
+
+        SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;
+        String[] tokens = tokenizer.tokenize("He reckons the current account deficit will narrow to only 8 billion.");
+
+        InputStream inputStreamPOSTagger = getClass().getResourceAsStream("/models/en-pos-maxent.bin");
+        POSModel posModel = new POSModel(inputStreamPOSTagger);
+        POSTaggerME posTagger = new POSTaggerME(posModel);
+        String tags[] = posTagger.tag(tokens);
+
+        InputStream inputStreamChunker = new FileInputStream("src/main/resources/models/en-chunker.bin");
+        ChunkerModel chunkerModel = new ChunkerModel(inputStreamChunker);
+        ChunkerME chunker = new ChunkerME(chunkerModel);
+        String[] chunks = chunker.chunk(tokens, tags);
+        assertThat(chunks).contains("B-NP", "B-VP", "B-NP", "I-NP", "I-NP", "I-NP", "B-VP", "I-VP", "B-PP", "B-NP", "I-NP", "I-NP", "O");
+    }
+}

apache-opennlp/src/test/java/com/baeldung/apache/opennlp/LanguageDetectorAndTrainingDataTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.apache.opennlp;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Arrays;
+import opennlp.tools.langdetect.Language;
+import opennlp.tools.langdetect.LanguageDetector;
+import opennlp.tools.langdetect.LanguageDetectorFactory;
+import opennlp.tools.langdetect.LanguageDetectorME;
+import opennlp.tools.langdetect.LanguageDetectorModel;
+import opennlp.tools.langdetect.LanguageDetectorSampleStream;
+import opennlp.tools.util.InputStreamFactory;
+import opennlp.tools.util.MarkableFileInputStreamFactory;
+import opennlp.tools.util.ObjectStream;
+import opennlp.tools.util.PlainTextByLineStream;
+import opennlp.tools.util.TrainingParameters;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class LanguageDetectorAndTrainingDataTest {
+
+    @Test
+    public void givenLanguageDictionary_whenLanguageDetect_thenLanguageIsDetected() throws FileNotFoundException, IOException {
+        InputStreamFactory dataIn = new MarkableFileInputStreamFactory(new File("src/main/resources/models/DoccatSample.txt"));
+        ObjectStream lineStream = new PlainTextByLineStream(dataIn, "UTF-8");
+        LanguageDetectorSampleStream sampleStream = new LanguageDetectorSampleStream(lineStream);
+        TrainingParameters params = new TrainingParameters();
+        params.put(TrainingParameters.ITERATIONS_PARAM, 100);
+        params.put(TrainingParameters.CUTOFF_PARAM, 5);
+        params.put("DataIndexer", "TwoPass");
+        params.put(TrainingParameters.ALGORITHM_PARAM, "NAIVEBAYES");
+
+        LanguageDetectorModel model = LanguageDetectorME.train(sampleStream, params, new LanguageDetectorFactory());
+
+        LanguageDetector ld = new LanguageDetectorME(model);
+        Language[] languages = ld.predictLanguages("estava em uma marcenaria na Rua Bruno");
+        assertThat(Arrays.asList(languages).toString()).contains("pob (0.9999999950605625)", "ita (4.939427661577956E-9)", "spa (9.665954064665144E-15)", 
+                "fra (8.250349924885834E-25)");
+    }
+}

apache-opennlp/src/test/java/com/baeldung/apache/opennlp/LemmetizerTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.apache.opennlp;
+
+import java.io.InputStream;
+import opennlp.tools.lemmatizer.DictionaryLemmatizer;
+import opennlp.tools.postag.POSModel;
+import opennlp.tools.postag.POSTaggerME;
+import opennlp.tools.tokenize.SimpleTokenizer;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class LemmetizerTest {
+
+    @Test
+    public void givenEnglishDictionary_whenLemmatize_thenLemmasAreDetected() throws Exception {
+
+        SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;
+        String[] tokens = tokenizer.tokenize("John has a sister named Penny.");
+
+        InputStream inputStreamPOSTagger = getClass().getResourceAsStream("/models/en-pos-maxent.bin");
+        POSModel posModel = new POSModel(inputStreamPOSTagger);
+        POSTaggerME posTagger = new POSTaggerME(posModel);
+        String tags[] = posTagger.tag(tokens);
+        InputStream dictLemmatizer = getClass().getResourceAsStream("/models/en-lemmatizer.dict");
+        DictionaryLemmatizer lemmatizer = new DictionaryLemmatizer(dictLemmatizer);
+        String[] lemmas = lemmatizer.lemmatize(tokens, tags);
+
+        assertThat(lemmas).contains("O", "have", "a", "sister", "name", "O", "O");
+    }
+}

apache-opennlp/src/test/java/com/baeldung/apache/opennlp/NamedEntityRecognitionTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.apache.opennlp;
+
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import opennlp.tools.namefind.NameFinderME;
+import opennlp.tools.namefind.TokenNameFinderModel;
+import opennlp.tools.tokenize.SimpleTokenizer;
+import opennlp.tools.util.Span;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class NamedEntityRecognitionTest {
+
+    @Test
+    public void givenEnglishPersonModel_whenNER_thenPersonsAreDetected() throws Exception {
+        
+        SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;
+        String[] tokens = tokenizer.tokenize("John is 26 years old. His best friend's name is Leonard. He has a sister named Penny.");
+        
+        InputStream inputStreamNameFinder = getClass().getResourceAsStream("/models/en-ner-person.bin");
+        TokenNameFinderModel model = new TokenNameFinderModel(inputStreamNameFinder);
+        NameFinderME nameFinderME = new NameFinderME(model);
+        List<Span> spans = Arrays.asList(nameFinderME.find(tokens));
+        assertThat(spans.toString()).isEqualTo("[[0..1) person, [13..14) person, [20..21) person]");
+        List<String> names = new ArrayList<String>();
+        int k = 0;
+        for (Span s : spans) {
+            names.add("");
+            for (int index = s.getStart(); index < s.getEnd(); index++) {
+                names.set(k, names.get(k) + tokens[index]);
+            }
+            k++;
+        }
+        assertThat(names).contains("John","Leonard","Penny");
+    }
+
+}

apache-opennlp/src/test/java/com/baeldung/apache/opennlp/POSTaggerTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.apache.opennlp;
+
+import java.io.InputStream;
+import opennlp.tools.postag.POSModel;
+import opennlp.tools.postag.POSTaggerME;
+import opennlp.tools.tokenize.SimpleTokenizer;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class POSTaggerTest {
+
+    @Test
+    public void givenPOSModel_whenPOSTagging_thenPOSAreDetected() throws Exception {
+
+        SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;
+        String[] tokens = tokenizer.tokenize("John has a sister named Penny.");
+
+        InputStream inputStreamPOSTagger = getClass().getResourceAsStream("/models/en-pos-maxent.bin");
+        POSModel posModel = new POSModel(inputStreamPOSTagger);
+        POSTaggerME posTagger = new POSTaggerME(posModel);
+        String tags[] = posTagger.tag(tokens);
+        assertThat(tags).contains("NNP", "VBZ", "DT", "NN", "VBN", "NNP", ".");
+    }
+}

apache-opennlp/src/test/java/com/baeldung/apache/opennlp/SentenceDetectionTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.apache.opennlp;
+
+import java.io.InputStream;
+import opennlp.tools.sentdetect.SentenceDetectorME;
+import opennlp.tools.sentdetect.SentenceModel;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class SentenceDetectionTest {
+
+    @Test
+    public void givenEnglishModel_whenDetect_thenSentencesAreDetected() throws Exception {
+
+        String paragraph = "This is a statement. This is another statement. Now is an abstract word for time, "
+                + "that is always flying. And my email address is [email protected].";
+
+        InputStream is = getClass().getResourceAsStream("/models/en-sent.bin");
+        SentenceModel model = new SentenceModel(is);
+
+        SentenceDetectorME sdetector = new SentenceDetectorME(model);
+
+        String sentences[] = sdetector.sentDetect(paragraph);
+        assertThat(sentences).contains("This is a statement.",
+                "This is another statement.",
+                "Now is an abstract word for time, that is always flying.",
+                "And my email address is [email protected].");
+    }
+}

apache-opennlp/src/test/java/com/baeldung/apache/opennlp/TokenizerTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.apache.opennlp;
+
+import java.io.InputStream;
+import opennlp.tools.tokenize.SimpleTokenizer;
+import opennlp.tools.tokenize.TokenizerME;
+import opennlp.tools.tokenize.TokenizerModel;
+import opennlp.tools.tokenize.WhitespaceTokenizer;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class TokenizerTest {
+
+    @Test
+    public void givenEnglishModel_whenTokenize_thenTokensAreDetected() throws Exception {
+        InputStream inputStream = getClass().getResourceAsStream("/models/en-token.bin");
+        TokenizerModel model = new TokenizerModel(inputStream);
+        TokenizerME tokenizer = new TokenizerME(model);
+        String[] tokens = tokenizer.tokenize("Baeldung is a Spring Resource.");
+        assertThat(tokens).contains("Baeldung", "is", "a", "Spring", "Resource", ".");
+    }
+    
+    @Test
+    public void givenWhitespaceTokenizer_whenTokenize_thenTokensAreDetected() throws Exception {
+        WhitespaceTokenizer tokenizer = WhitespaceTokenizer.INSTANCE;
+        String[] tokens = tokenizer.tokenize("Baeldung is a Spring Resource.");
+        assertThat(tokens).contains("Baeldung", "is", "a", "Spring", "Resource.");
+    }
+    
+    @Test
+    public void givenSimpleTokenizer_whenTokenize_thenTokensAreDetected() throws Exception {
+        SimpleTokenizer tokenizer = SimpleTokenizer.INSTANCE;
+        String[] tokens = tokenizer.tokenize("Baeldung is a Spring Resource.");
+        assertThat(tokens).contains("Baeldung", "is", "a", "Spring", "Resource", ".");
+    }
+
+}

core-kotlin/src/test/kotlin/com/baeldung/kotlin/objects/Counter.kt

@@ -0,0 +1,15 @@
+package com.baeldung.kotlin.objects
+
+object Counter {
+    private var count: Int = 0
+
+    fun currentCount() = count
+
+    fun increment() {
+        ++count
+    }
+
+    fun decrement() {
+        --count
+    }
+}

core-kotlin/src/test/kotlin/com/baeldung/kotlin/objects/ObjectsTest.kt

@@ -0,0 +1,36 @@
+package com.baeldung.kotlin.objects
+
+import org.junit.Assert
+import org.junit.Test
+
+class ObjectsTest {
+    @Test
+    fun singleton() {
+
+        Assert.assertEquals(42, SimpleSingleton.answer)
+        Assert.assertEquals("Hello, world!", SimpleSingleton.greet("world"))
+    }
+
+    @Test
+    fun counter() {
+        Assert.assertEquals(0, Counter.currentCount())
+        Counter.increment()
+        Assert.assertEquals(1, Counter.currentCount())
+        Counter.decrement()
+        Assert.assertEquals(0, Counter.currentCount())
+    }
+
+    @Test
+    fun comparator() {
+        val strings = listOf("Hello", "World")
+        val sortedStrings = strings.sortedWith(ReverseStringComparator)
+
+        Assert.assertEquals(listOf("World", "Hello"), sortedStrings)
+    }
+
+    @Test
+    fun companion() {
+        Assert.assertEquals("You can see me", OuterClass.public)
+        // Assert.assertEquals("You can't see me", OuterClass.secret) // Cannot access 'secret'
+    }
+}

core-kotlin/src/test/kotlin/com/baeldung/kotlin/objects/OuterClass.kt

@@ -0,0 +1,10 @@
+package com.baeldung.kotlin.objects
+
+class OuterClass {
+    companion object {
+        private val secret = "You can't see me"
+        val public = "You can see me"
+    }
+
+    fun getSecretValue() = secret
+}

core-kotlin/src/test/kotlin/com/baeldung/kotlin/objects/ReverseStringComparator.kt

@@ -0,0 +1,5 @@
+package com.baeldung.kotlin.objects
+
+object ReverseStringComparator : Comparator<String> {
+    override fun compare(o1: String, o2: String) = o1.reversed().compareTo(o2.reversed())
+}

core-kotlin/src/test/kotlin/com/baeldung/kotlin/objects/SimpleSingleton.kt

@@ -0,0 +1,7 @@
+package com.baeldung.kotlin.objects
+
+object SimpleSingleton {
+    val answer = 42;
+
+    fun greet(name: String) = "Hello, $name!"
+}

core-kotlin/src/test/kotlin/com/baeldung/kotlin/objects/StaticClass.kt

@@ -0,0 +1,8 @@
+package com.baeldung.kotlin.objects
+
+class StaticClass {
+    companion object {
+        @JvmStatic
+        val staticField = 42
+    }
+}

pom.xml

@@ -42,6 +42,7 @@
         <module>apache-thrift</module>
         <module>apache-curator</module>
         <module>apache-zookeeper</module>
+        <module>apache-opennlp</module>
         <module>autovalue</module>
         <module>axon</module>
         <module>bootique</module>

rxjava/src/test/java/com/baeldung/rxjava/filters/RxJavaFilterOperatorsTest.java

@@ -0,0 +1,202 @@
+package com.baeldung.rxjava.filters;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.observers.TestSubscriber;
+
+public class RxJavaFilterOperatorsTest {
+
+    @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/src/test/java/com/baeldung/rxjava/filters/RxJavaSkipOperatorsTest.java

@@ -0,0 +1,105 @@
+package com.baeldung.rxjava.filters;
+
+import org.junit.Test;
+
+import rx.Observable;
+import rx.observers.TestSubscriber;
+
+public class RxJavaSkipOperatorsTest {
+
+    @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/src/test/java/com/baeldung/rxjava/filters/RxJavaTimeFilteringOperatorsTest.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 RxJavaTimeFilteringOperatorsTest {
+
+    @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);
+    }
+}

spring-boot/pom.xml

@@ -28,7 +28,6 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-jpa</artifactId>
         </dependency>
-
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-actuator</artifactId>

spring-boot/src/main/java/com/baeldung/errorhandling/ErrorHandlingApplication.java

@@ -0,0 +1,26 @@
+package com.baeldung.errorhandling;
+
+import com.baeldung.autoconfiguration.MySQLAutoconfiguration;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.web.servlet.handler.HandlerMappingIntrospector;
+
+@SpringBootApplication(exclude = {MySQLAutoconfiguration.class})
+@ComponentScan(basePackages = "com.baeldung.errorhandling")
+public class ErrorHandlingApplication {
+
+    public static void main(String [] args) {
+        System.setProperty("spring.profiles.active", "errorhandling");
+        SpringApplication.run(ErrorHandlingApplication.class, args);
+    }
+
+    @Bean(name = "mvcHandlerMappingIntrospector")
+    public HandlerMappingIntrospector mvcHandlerMappingIntrospector(ApplicationContext context) {
+        return new HandlerMappingIntrospector(context);
+    }
+
+
+}

spring-boot/src/main/java/com/baeldung/errorhandling/controllers/IndexController.java

@@ -0,0 +1,26 @@
+package com.baeldung.errorhandling.controllers;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+
+@Controller
+public class IndexController {
+
+    @GetMapping(value = {"/", ""})
+    public String index() {
+        return "index";
+    }
+
+    @GetMapping(value = {"/server_error"})
+    public String triggerServerError() {
+        "ser".charAt(30);
+        return "index";
+    }
+
+    @PostMapping(value = {"/general_error"})
+    public String triggerGeneralError() {
+        return "index";
+    }
+
+}

spring-boot/src/main/java/com/baeldung/errorhandling/controllers/MyErrorController.java

@@ -0,0 +1,38 @@
+package com.baeldung.errorhandling.controllers;
+
+import org.springframework.boot.autoconfigure.web.ErrorController;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import javax.servlet.RequestDispatcher;
+import javax.servlet.http.HttpServletRequest;
+
+@Controller
+public class MyErrorController implements ErrorController {
+
+    public MyErrorController() {}
+
+    @RequestMapping(value = "/error")
+    public String handleError(HttpServletRequest request) {
+
+        Integer statusCode =
+          Integer.valueOf(request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE).toString());
+
+        if(statusCode == HttpStatus.NOT_FOUND.value()) {
+            return "error-404";
+        }
+        else if(statusCode == HttpStatus.INTERNAL_SERVER_ERROR.value()) {
+            return "error-500";
+        }
+        else {
+            return "error";
+        }
+    }
+
+    @Override
+    public String getErrorPath() {
+        return "/error";
+    }
+
+}

spring-boot/src/main/resources/application-errorhandling.properties

@@ -0,0 +1,10 @@
+#server
+server.port=9000
+server.servlet-path=/
+server.context-path=/
+#server.error.whitelabel.enabled=false
+
+#spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration
+
+#for Spring Boot 2.0+
+#spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration