JAVA-1848: new module apache-libraries to group apache-* modules with a

single article
2020-06-12 12:09:52 +05:30
parent 3cb48fd96e
commit b3df35ba3d
57 changed files with 4176 additions and 0 deletions
@@ -0,0 +1,19 @@
+package com.baeldung.apache.beam.intro;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import com.baeldung.apache.beam.intro.WordCount;
+
+public class WordCountUnitTest {
+    
+    @Test
+    // @Ignore
+    public void givenInputFile_whenWordCountRuns_thenJobFinishWithoutError() {
+        boolean jobDone = WordCount.wordCount("src/test/resources/wordcount.txt", "target/output");
+        assertTrue(jobDone);
+    }
+
+}
@@ -0,0 +1,22 @@
+package com.baeldung.apache.curator;
+
+import org.apache.curator.RetryPolicy;
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.framework.CuratorFrameworkFactory;
+import org.apache.curator.retry.RetryNTimes;
+import org.junit.Before;
+
+public abstract class BaseManualTest {
+
+    @Before
+    public void setup() {
+        org.apache.log4j.BasicConfigurator.configure();
+    }
+
+    protected CuratorFramework newClient() {
+        int sleepMsBetweenRetries = 100;
+        int maxRetries = 3;
+        RetryPolicy retryPolicy = new RetryNTimes(maxRetries, sleepMsBetweenRetries);
+        return CuratorFrameworkFactory.newClient("127.0.0.1:2181", retryPolicy);
+    }
+}
@@ -0,0 +1,89 @@
+package com.baeldung.apache.curator.configuration;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.x.async.AsyncCuratorFramework;
+import org.junit.Test;
+
+import com.baeldung.apache.curator.BaseManualTest;
+
+public class ConfigurationManagementManualTest extends BaseManualTest {
+
+    private static final String KEY_FORMAT = "/%s";
+
+    @Test
+    public void givenPath_whenCreateKey_thenValueIsStored() throws Exception {
+        try (CuratorFramework client = newClient()) {
+            client.start();
+            AsyncCuratorFramework async = AsyncCuratorFramework.wrap(client);
+            String key = getKey();
+            String expected = "my_value";
+
+            // Create key nodes structure
+            client.create()
+                .forPath(key);
+
+            // Set data value for our key
+            async.setData()
+                .forPath(key, expected.getBytes());
+
+            // Get data value
+            AtomicBoolean isEquals = new AtomicBoolean();
+            async.getData()
+                .forPath(key)
+                .thenAccept(
+                    data -> isEquals.set(new String(data).equals(expected)));
+
+            await().until(() -> assertThat(isEquals.get()).isTrue());
+        }
+    }
+
+    @Test
+    public void givenPath_whenWatchAKeyAndStoreAValue_thenWatcherIsTriggered()
+        throws Exception {
+        try (CuratorFramework client = newClient()) {
+            client.start();
+            AsyncCuratorFramework async = AsyncCuratorFramework.wrap(client);
+            String key = getKey();
+            String expected = "my_value";
+
+            // Create key structure
+            async.create()
+                .forPath(key);
+
+            List<String> changes = new ArrayList<>();
+
+            // Watch data value
+            async.watched()
+                .getData()
+                .forPath(key)
+                .event()
+                .thenAccept(watchedEvent -> {
+                    try {
+                        changes.add(new String(client.getData()
+                            .forPath(watchedEvent.getPath())));
+                    } catch (Exception e) {
+                        // fail ...
+                    }
+                });
+
+            // Set data value for our key
+            async.setData()
+                .forPath(key, expected.getBytes());
+
+            await().until(() -> assertThat(changes.size() > 0).isTrue());
+        }
+    }
+
+    private String getKey() {
+        return String.format(KEY_FORMAT, UUID.randomUUID()
+            .toString());
+    }
+}
@@ -0,0 +1,79 @@
+package com.baeldung.apache.curator.connection;
+
+import static com.jayway.awaitility.Awaitility.await;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.curator.RetryPolicy;
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.framework.CuratorFrameworkFactory;
+import org.apache.curator.retry.RetryNTimes;
+import org.apache.curator.x.async.AsyncCuratorFramework;
+import org.junit.Test;
+
+public class ConnectionManagementManualTest {
+
+    @Test
+    public void givenRunningZookeeper_whenOpenConnection_thenClientIsOpened()
+        throws Exception {
+        int sleepMsBetweenRetries = 100;
+        int maxRetries = 3;
+        RetryPolicy retryPolicy = new RetryNTimes(maxRetries,
+            sleepMsBetweenRetries);
+
+        try (CuratorFramework client = CuratorFrameworkFactory
+            .newClient("127.0.0.1:2181", retryPolicy)) {
+            client.start();
+
+            assertThat(client.checkExists()
+                .forPath("/")).isNotNull();
+        }
+    }
+
+    @Test
+    public void givenRunningZookeeper_whenOpenConnectionUsingAsyncNotBlocking_thenClientIsOpened()
+        throws InterruptedException {
+        int sleepMsBetweenRetries = 100;
+        int maxRetries = 3;
+        RetryPolicy retryPolicy = new RetryNTimes(maxRetries,
+            sleepMsBetweenRetries);
+
+        try (CuratorFramework client = CuratorFrameworkFactory
+            .newClient("127.0.0.1:2181", retryPolicy)) {
+            client.start();
+            AsyncCuratorFramework async = AsyncCuratorFramework.wrap(client);
+
+            AtomicBoolean exists = new AtomicBoolean(false);
+
+            async.checkExists()
+                .forPath("/")
+                .thenAcceptAsync(s -> exists.set(s != null));
+
+            await().until(() -> assertThat(exists.get()).isTrue());
+        }
+    }
+
+    @Test
+    public void givenRunningZookeeper_whenOpenConnectionUsingAsyncBlocking_thenClientIsOpened()
+        throws InterruptedException {
+        int sleepMsBetweenRetries = 100;
+        int maxRetries = 3;
+        RetryPolicy retryPolicy = new RetryNTimes(maxRetries,
+            sleepMsBetweenRetries);
+
+        try (CuratorFramework client = CuratorFrameworkFactory
+            .newClient("127.0.0.1:2181", retryPolicy)) {
+            client.start();
+            AsyncCuratorFramework async = AsyncCuratorFramework.wrap(client);
+
+            AtomicBoolean exists = new AtomicBoolean(false);
+
+            async.checkExists()
+                .forPath("/")
+                .thenAccept(s -> exists.set(s != null));
+
+            await().until(() -> assertThat(exists.get()).isTrue());
+        }
+    }
+}
@@ -0,0 +1,49 @@
+package com.baeldung.apache.curator.modeled;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.x.async.AsyncCuratorFramework;
+import org.apache.curator.x.async.modeled.JacksonModelSerializer;
+import org.apache.curator.x.async.modeled.ModelSpec;
+import org.apache.curator.x.async.modeled.ModeledFramework;
+import org.apache.curator.x.async.modeled.ZPath;
+import org.junit.Test;
+
+import com.baeldung.apache.curator.BaseManualTest;
+
+public class ModelTypedExamplesManualTest extends BaseManualTest {
+
+    @Test
+    public void givenPath_whenStoreAModel_thenNodesAreCreated()
+        throws InterruptedException {
+
+        ModelSpec<HostConfig> mySpec = ModelSpec
+            .builder(ZPath.parseWithIds("/config/dev"),
+                JacksonModelSerializer.build(HostConfig.class))
+            .build();
+
+        try (CuratorFramework client = newClient()) {
+            client.start();
+            AsyncCuratorFramework async = AsyncCuratorFramework.wrap(client);
+            ModeledFramework<HostConfig> modeledClient = ModeledFramework
+                .wrap(async, mySpec);
+
+            modeledClient.set(new HostConfig("host-name", 8080));
+
+            modeledClient.read()
+                .whenComplete((value, e) -> {
+                    if (e != null) {
+                        fail("Cannot read host config", e);
+                    } else {
+                        assertThat(value).isNotNull();
+                        assertThat(value.getHostname()).isEqualTo("host-name");
+                        assertThat(value.getPort()).isEqualTo(8080);
+                    }
+
+                });
+        }
+
+    }
+}
@@ -0,0 +1,74 @@
+package com.baeldung.apache.curator.recipes;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.framework.recipes.leader.LeaderSelector;
+import org.apache.curator.framework.recipes.leader.LeaderSelectorListener;
+import org.apache.curator.framework.recipes.locks.InterProcessSemaphoreMutex;
+import org.apache.curator.framework.recipes.shared.SharedCount;
+import org.apache.curator.framework.state.ConnectionState;
+import org.junit.Test;
+
+import com.baeldung.apache.curator.BaseManualTest;
+
+public class RecipesManualTest extends BaseManualTest {
+
+    @Test
+    public void givenRunningZookeeper_whenUsingLeaderElection_thenNoErrors() {
+        try (CuratorFramework client = newClient()) {
+            client.start();
+            LeaderSelector leaderSelector = new LeaderSelector(client, "/mutex/select/leader/for/job/A", new LeaderSelectorListener() {
+
+                @Override
+                public void stateChanged(CuratorFramework client, ConnectionState newState) {
+
+                }
+
+                @Override
+                public void takeLeadership(CuratorFramework client) throws Exception {
+                    // I'm the leader of the job A !
+                }
+
+            });
+
+            leaderSelector.start();
+
+            // Wait until the job A is done among all the members
+
+            leaderSelector.close();
+        }
+    }
+
+    @Test
+    public void givenRunningZookeeper_whenUsingSharedLock_thenNoErrors() throws Exception {
+        try (CuratorFramework client = newClient()) {
+            client.start();
+            InterProcessSemaphoreMutex sharedLock = new InterProcessSemaphoreMutex(client, "/mutex/process/A");
+
+            sharedLock.acquire();
+
+            // Do process A
+
+            sharedLock.release();
+        }
+    }
+
+    @Test
+    public void givenRunningZookeeper_whenUsingSharedCounter_thenCounterIsIncrement() throws Exception {
+        try (CuratorFramework client = newClient()) {
+            client.start();
+
+            try (SharedCount counter = new SharedCount(client, "/counters/A", 0)) {
+                counter.start();
+
+                counter.setCount(0);
+                counter.setCount(counter.getCount() + 1);
+
+                assertThat(counter.getCount()).isEqualTo(1);
+            }
+
+        }
+    }
+
+}
@@ -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 ChunkerUnitTest {
+
+    @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");
+    }
+}
@@ -0,0 +1,44 @@
+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 static org.assertj.core.api.Assertions.tuple;
+import org.junit.Test;
+
+public class LanguageDetectorAndTrainingDataUnitTest {
+
+    @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)).extracting("lang", "confidence").contains(tuple("pob", 0.9999999950605625),
+                 tuple("ita", 4.939427661577956E-9), tuple("spa", 9.665954064665144E-15),
+                tuple("fra", 8.250349924885834E-25));
+    }
+}
@@ -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 LemmetizerUnitTest {
+
+    @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");
+    }
+}
@@ -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 NamedEntityRecognitionUnitTest {
+
+    @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");
+    }
+
+}
@@ -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 POSTaggerUnitTest {
+
+    @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", ".");
+    }
+}
@@ -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 SentenceDetectionUnitTest {
+
+    @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 google@gmail.com.";
+
+        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 google@gmail.com.");
+    }
+}
@@ -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 TokenizerUnitTest {
+
+    @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", ".");
+    }
+
+}
@@ -0,0 +1,83 @@
+package com.baeldung.avro.util.serealization;
+
+import com.baeldung.avro.util.model.Active;
+import com.baeldung.avro.util.model.AvroHttpRequest;
+import com.baeldung.avro.util.model.ClientIdentifier;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+import static org.junit.Assert.*;
+
+public class AvroSerealizerDeSerealizerUnitTest {
+
+    AvroSerealizer serealizer;
+    AvroDeSerealizer deSerealizer;
+    AvroHttpRequest request;
+
+    @Before
+    public void setUp() throws Exception {
+        serealizer = new AvroSerealizer();
+        deSerealizer = new AvroDeSerealizer();
+
+        ClientIdentifier clientIdentifier = ClientIdentifier.newBuilder()
+            .setHostName("localhost")
+            .setIpAddress("255.255.255.0")
+            .build();
+
+        List<CharSequence> employees = new ArrayList();
+        employees.add("James");
+        employees.add("Alice");
+        employees.add("David");
+        employees.add("Han");
+
+        request = AvroHttpRequest.newBuilder()
+            .setRequestTime(01l)
+            .setActive(Active.YES)
+            .setClientIdentifier(clientIdentifier)
+            .setEmployeeNames(employees)
+            .build();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+    }
+
+    @Test
+    public void WhenSerializedUsingJSONEncoder_thenObjectGetsSerialized() {
+        byte[] data = serealizer.serealizeAvroHttpRequestJSON(request);
+        assertTrue(Objects.nonNull(data));
+        assertTrue(data.length > 0);
+    }
+
+    @Test
+    public void WhenSerializedUsingBinaryEncoder_thenObjectGetsSerialized() {
+        byte[] data = serealizer.serealizeAvroHttpRequestBinary(request);
+        assertTrue(Objects.nonNull(data));
+        assertTrue(data.length > 0);
+    }
+
+    @Test
+    public void WhenDeserializeUsingJSONDecoder_thenActualAndExpectedObjectsAreEqual() {
+        byte[] data = serealizer.serealizeAvroHttpRequestJSON(request);
+        AvroHttpRequest actualRequest = deSerealizer.deSerealizeAvroHttpRequestJSON(data);
+        assertEquals(actualRequest, request);
+        assertTrue(actualRequest.getRequestTime()
+            .equals(request.getRequestTime()));
+    }
+
+    @Test
+    public void WhenDeserializeUsingBinaryecoder_thenActualAndExpectedObjectsAreEqual() {
+        byte[] data = serealizer.serealizeAvroHttpRequestBinary(request);
+        AvroHttpRequest actualRequest = deSerealizer.deSerealizeAvroHttpRequestBinary(data);
+        assertEquals(actualRequest, request);
+        assertTrue(actualRequest.getRequestTime()
+            .equals(request.getRequestTime()));
+    }
+    
+}
+
@@ -0,0 +1,97 @@
+package com.baeldung.bval.validation;
+
+import java.io.File;
+import java.util.Set;
+
+import javax.validation.ConstraintViolation;
+import javax.validation.Validation;
+import javax.validation.Validator;
+import javax.validation.ValidatorFactory;
+
+import org.apache.bval.jsr.ApacheValidationProvider;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.baeldung.bval.model.User;
+
+import static org.junit.Assert.*;
+
+public class ValidationIntegrationTest {
+    private static ValidatorFactory validatorFactory;
+    private static Validator validator;
+
+    @BeforeClass
+    public static void setup() {
+        validatorFactory = Validation.byProvider(ApacheValidationProvider.class)
+            .configure()
+            .buildValidatorFactory();
+        validator = validatorFactory.getValidator();
+    }
+
+    @Test
+    public void givenUser_whenValidate_thenValidationViolations() {
+        User user = new User("ana@yahoo.com", "pass", "nameTooLong_______________", 15);
+
+        Set<ConstraintViolation<User>> violations = validator.validate(user);
+        assertTrue("no violations", violations.size() > 0);
+    }
+	
+    @Test
+    public void givenInvalidAge_whenValidateProperty_thenConstraintViolation() {
+        User user = new User("ana@yahoo.com", "pass", "Ana", 12);
+
+        Set<ConstraintViolation<User>> propertyViolations = validator.validateProperty(user, "age");
+        assertEquals("size is not 1", 1, propertyViolations.size());
+    }
+	
+    @Test
+    public void givenValidAge_whenValidateValue_thenNoConstraintViolation() {
+        User user = new User("ana@yahoo.com", "pass", "Ana", 18);
+    
+        Set<ConstraintViolation<User>> valueViolations = validator.validateValue(User.class, "age", 20);
+        assertEquals("size is not 0", 0, valueViolations.size());
+    }
+
+    @Test
+    public void whenValidateNonJSR_thenCorrect() {
+        User user = new User("ana@yahoo.com", "pass", "Ana", 20);
+        user.setCardNumber("1234");
+        user.setIban("1234");
+        user.setWebsite("10.0.2.50");
+        user.setMainDirectory(new File("."));
+		
+        Set<ConstraintViolation<User>> violations = validator.validateProperty(user, "iban");
+        assertEquals("size is not 1", 1, violations.size());
+
+        violations = validator.validateProperty(user, "website");
+        assertEquals("size is not 0", 0, violations.size());
+
+        violations = validator.validateProperty(user, "mainDirectory");
+        assertEquals("size is not 0", 0, violations.size());
+    }
+
+    @Test
+    public void givenInvalidPassword_whenValidatePassword_thenConstraintViolation() {
+        User user = new User("ana@yahoo.com", "password", "Ana", 20);
+        Set<ConstraintViolation<User>> violations = validator.validateProperty(user, "password");
+        assertEquals("message incorrect", "Invalid password", violations.iterator()
+            .next()
+            .getMessage());
+    }
+	
+    @Test
+    public void givenValidPassword_whenValidatePassword_thenNoConstraintViolation() {
+        User user = new User("ana@yahoo.com", "password#", "Ana", 20);
+		
+        Set<ConstraintViolation<User>>  violations = validator.validateProperty(user, "password");
+        assertEquals("size is not 0", 0, violations.size());
+    }
+
+    @AfterClass
+    public static void close() {
+        if (validatorFactory != null) {
+            validatorFactory.close();
+        }
+    }
+}
@@ -0,0 +1,110 @@
+package com.baeldung.geode;
+
+import com.baeldung.geode.functions.UpperCaseNames;
+import org.apache.geode.cache.Region;
+import org.apache.geode.cache.client.ClientCache;
+import org.apache.geode.cache.client.ClientCacheFactory;
+import org.apache.geode.cache.client.ClientRegionShortcut;
+import org.apache.geode.cache.execute.Execution;
+import org.apache.geode.cache.execute.FunctionService;
+import org.apache.geode.cache.query.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+
+public class GeodeSamplesLiveTest {
+
+    ClientCache cache = null;
+    Region<String, String> region = null;
+    Region<Integer, Customer> queryRegion = null;
+    Region<CustomerKey, Customer> customerRegion = null;
+
+    @Before
+    public void connect() {
+        this.cache = new ClientCacheFactory().addPoolLocator("localhost", 10334)
+            .create();
+        this.region = this.cache.<String, String> createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY)
+            .create("baeldung");
+        this.customerRegion = this.cache.<CustomerKey, Customer> createClientRegionFactory(ClientRegionShortcut.CACHING_PROXY)
+            .create("baeldung-customers");
+    }
+
+    @After
+    public void cleanup() {
+        this.cache.close();
+    }
+
+    @Test
+    public void whenSendMessageToRegion_thenMessageSavedSuccessfully() {
+
+        this.region.put("1", "Hello");
+        this.region.put("2", "Baeldung");
+
+        assertEquals("Hello", region.get("1"));
+        assertEquals("Baeldung", region.get("2"));
+
+    }
+
+    @Test
+    public void whenPutMultipleValuesAtOnce_thenValuesSavedSuccessfully() {
+
+        Supplier<Stream<String>> keys = () -> Stream.of("A", "B", "C", "D", "E");
+        Map<String, String> values = keys.get()
+            .collect(Collectors.toMap(Function.identity(), String::toLowerCase));
+
+        this.region.putAll(values);
+
+        keys.get()
+            .forEach(k -> assertEquals(k.toLowerCase(), this.region.get(k)));
+
+    }
+
+    @Test
+    public void whenPutCustomKey_thenValuesSavedSuccessfully() {
+        CustomerKey key = new CustomerKey(123);
+        Customer customer = new Customer(key, "William", "Russell", 35);
+
+        Map<CustomerKey, Customer> customerInfo = new HashMap<>();
+        customerInfo.put(key, customer);
+
+        this.customerRegion.putAll(customerInfo);
+
+        Customer storedCustomer = this.customerRegion.get(key);
+        assertEquals("William", storedCustomer.getFirstName());
+        assertEquals("Russell", storedCustomer.getLastName());
+
+    }
+
+    @Test
+    public void whenFindACustomerUsingOQL_thenCorrectCustomerObject() throws NameResolutionException, TypeMismatchException, QueryInvocationTargetException, FunctionDomainException {
+
+        Map<CustomerKey, Customer> data = new HashMap<>();
+        data.put(new CustomerKey(1), new Customer("Gheorge", "Manuc", 36));
+        data.put(new CustomerKey(2), new Customer("Allan", "McDowell", 43));
+        this.customerRegion.putAll(data);
+
+        QueryService queryService = this.cache.getQueryService();
+        String query = "select * from /baeldung-customers c where c.firstName = 'Allan'";
+        SelectResults<Customer> queryResults = (SelectResults<Customer>) queryService.newQuery(query)
+            .execute();
+        assertEquals(1, queryResults.size());
+
+    }
+
+    @Test
+    public void whenExecuteUppercaseNames_thenCustomerNamesAreUppercased() {
+        Execution execution = FunctionService.onRegion(this.customerRegion);
+        execution.execute(UpperCaseNames.class.getName());
+        Customer customer = this.customerRegion.get(new CustomerKey(1));
+        assertEquals("GHEORGE", customer.getFirstName());
+    }
+}
@@ -0,0 +1,41 @@
+package com.baeldung.meecrowave;
+
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.apache.meecrowave.Meecrowave;
+import org.apache.meecrowave.junit.MonoMeecrowave;
+import org.apache.meecrowave.testing.ConfigurationInject;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.Response;
+
+@RunWith(MonoMeecrowave.Runner.class)
+public class ArticleEndpointsUnitTest {
+    
+    @ConfigurationInject
+    private Meecrowave.Builder config;
+    private static OkHttpClient client;
+    
+    @BeforeClass
+    public static void setup() {
+        client = new OkHttpClient();
+    }
+    
+   @Test
+    public void whenRetunedArticle_thenCorrect() throws IOException {
+        final String base = "http://localhost:"+config.getHttpPort();
+        
+        Request request = new Request.Builder()
+          .url(base+"/article")
+          .build();
+        Response response = client.newCall(request).execute();
+        assertEquals(200,  response.code());
+    }
+}
@@ -0,0 +1,108 @@
+package com.baeldung.solrjava;
+
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
+
+import org.apache.solr.client.solrj.SolrQuery;
+import org.apache.solr.client.solrj.SolrServerException;
+import org.apache.solr.client.solrj.response.QueryResponse;
+import org.apache.solr.common.SolrDocument;
+import org.apache.solr.common.SolrDocumentList;
+import org.junit.Before;
+import org.junit.Test;
+
+public class SolrJavaLiveTest {
+
+    private SolrJavaIntegration solrJavaIntegration;
+
+    @Before
+    public void setUp() throws Exception {
+
+        solrJavaIntegration = new SolrJavaIntegration("http://localhost:8983/solr/bigboxstore");
+        solrJavaIntegration.addSolrDocument("123456", "Kenmore Dishwasher", "599.99");
+    }
+
+    @Test
+    public void whenAdd_thenVerifyAddedByQueryOnId() throws SolrServerException, IOException {
+
+        SolrQuery query = new SolrQuery();
+        query.set("q", "id:123456");
+        QueryResponse response = null;
+
+        response = solrJavaIntegration.getSolrClient().query(query);
+
+        SolrDocumentList docList = response.getResults();
+        assertEquals(1, docList.getNumFound());
+
+        for (SolrDocument doc : docList) {
+            assertEquals("Kenmore Dishwasher", (String) doc.getFieldValue("name"));
+            assertEquals((Double) 599.99, (Double) doc.getFieldValue("price"));
+        }
+    }
+
+    @Test
+    public void whenAdd_thenVerifyAddedByQueryOnPrice() throws SolrServerException, IOException {
+
+        SolrQuery query = new SolrQuery();
+        query.set("q", "price:599.99");
+        QueryResponse response = null;
+
+        response = solrJavaIntegration.getSolrClient().query(query);
+
+        SolrDocumentList docList = response.getResults();
+        assertEquals(1, docList.getNumFound());
+
+        for (SolrDocument doc : docList) {
+            assertEquals("123456", (String) doc.getFieldValue("id"));
+            assertEquals((Double) 599.99, (Double) doc.getFieldValue("price"));
+        }
+    }
+
+    @Test
+    public void whenAdd_thenVerifyAddedByQuery() throws SolrServerException, IOException {
+
+        SolrDocument doc = solrJavaIntegration.getSolrClient().getById("123456");
+        assertEquals("Kenmore Dishwasher", (String) doc.getFieldValue("name"));
+        assertEquals((Double) 599.99, (Double) doc.getFieldValue("price"));
+    }
+
+    @Test
+    public void whenAddBean_thenVerifyAddedByQuery() throws SolrServerException, IOException {
+
+        ProductBean pBean = new ProductBean("888", "Apple iPhone 6s", "299.99");
+        solrJavaIntegration.addProductBean(pBean);
+
+        SolrDocument doc = solrJavaIntegration.getSolrClient().getById("888");
+        assertEquals("Apple iPhone 6s", (String) doc.getFieldValue("name"));
+        assertEquals((Double) 299.99, (Double) doc.getFieldValue("price"));
+    }
+
+    @Test
+    public void whenDeleteById_thenVerifyDeleted() throws SolrServerException, IOException {
+
+        solrJavaIntegration.deleteSolrDocumentById("123456");
+
+        SolrQuery query = new SolrQuery();
+        query.set("q", "id:123456");
+        QueryResponse response = solrJavaIntegration.getSolrClient().query(query);
+
+        SolrDocumentList docList = response.getResults();
+        assertEquals(0, docList.getNumFound());
+    }
+
+    @Test
+    public void whenDeleteByQuery_thenVerifyDeleted() throws SolrServerException, IOException {
+
+        solrJavaIntegration.deleteSolrDocumentByQuery("name:Kenmore Dishwasher");
+
+        SolrQuery query = new SolrQuery();
+        query.set("q", "id:123456");
+        QueryResponse response = null;
+
+        response = solrJavaIntegration.getSolrClient().query(query);
+
+        SolrDocumentList docList = response.getResults();
+        assertEquals(0, docList.getNumFound());
+    }
+}
@@ -0,0 +1,16 @@
+We've all heard the scare stories about North Korea: the homemade nuclear arsenal built while their people starve and then aimed imprecisely at the rest of the world, a 
+leader so deluded he makes L Ron Hubbard look like a man excessively overburdened with self-doubt and their deep-seated belief that foreign capitalists will invade at any 
+moment and steal all their bauxite.
+The popular portrayal of this Marxist nation is something like one of the more harrowing episodes of M*A*S*H, only with the cast of wacky characters replaced by twitchy, 
+heavily armed Stalinist meth addicts
+Cracked would like to take a moment to celebrate the good things about North Korea though, the things that the country's enemies prefer to suppress as part of their politically 
+motivated jealousy. Like how no different to you and me, there's nothing every North Korean likes more after an 18 hour shift at the phosphorus plant than a nice beer to go with 
+his dried fish ration. Ever attentive to its people's needs and in the twinkling of a decade, North Korea's leadership bought, disassembled, transported and rebuilt a British 
+brewery in order to discover and reproduce the secrets of beer and then brew the sweet nectar for its hardworking people, up to 18 bottles at a time. And with minimal fatalities. 
+When was the last time YOUR leader got a beer for YOU, American? (NB do not answer this question if you are Henry Louis Gates).
+Or how about the fried chicken restaurant that downtown Pyongyang boasts? Yes real chicken, fried and then delivered to your sleeping cube, with optional beer if you like! You 
+don't even have to remove the feathers or pull out the gizzard yourself. Mostly. Americans must eat their fried chicken from a bucket, like swine, sold by a company so secretive 
+that even the very blend of seasoning used is intentionally kept from them. And they call North Korea paranoid?
+And how many nations would entertain the syphilitic, bourgeois ramblings of Bill Clinton let alone permit him anywhere near their proud womenfolk? Only wise Kim Jong Il could see 
+past Bill's many, many imperfections and treat him with the pity and kindness he deserves, accepting his feeble pleas to pardon the American spies rightly convicted of photographing 
+the nation's sensitive beetroot fields.