BAEL-3091: The Prototype Pattern in Java (changed code based on valid comments from a reader)

libraries-2/src/test/java/com/baeldung/chroniclemap/ChronicleMapUnitTest.java

@@ -0,0 +1,132 @@
+package com.baeldung.chroniclemap;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertThat;
+
+import java.io.File;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import net.openhft.chronicle.core.values.LongValue;
+import net.openhft.chronicle.map.ChronicleMap;
+import net.openhft.chronicle.map.ExternalMapQueryContext;
+import net.openhft.chronicle.map.MapEntry;
+import net.openhft.chronicle.values.Values;
+
+public class ChronicleMapUnitTest {
+
+    static ChronicleMap<LongValue, CharSequence> persistedCountryMap = null;
+
+    static ChronicleMap<LongValue, CharSequence> inMemoryCountryMap = null;
+
+    static ChronicleMap<Integer, Set<Integer>> multiMap = null;
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @BeforeClass
+    public static void init() {
+        try {
+            inMemoryCountryMap = ChronicleMap.of(LongValue.class, CharSequence.class)
+                .name("country-map")
+                .entries(50)
+                .averageValue("America")
+                .create();
+
+            persistedCountryMap = ChronicleMap.of(LongValue.class, CharSequence.class)
+                .name("country-map")
+                .entries(50)
+                .averageValue("America")
+                .createPersistedTo(new File(System.getProperty("user.home") + "/country-details.dat"));
+
+            Set<Integer> averageValue = IntStream.of(1, 2)
+                .boxed()
+                .collect(Collectors.toSet());
+            multiMap = ChronicleMap.of(Integer.class, (Class<Set<Integer>>) (Class) Set.class)
+                .name("multi-map")
+                .entries(50)
+                .averageValue(averageValue)
+                .create();
+
+            LongValue qatarKey = Values.newHeapInstance(LongValue.class);
+            qatarKey.setValue(1);
+            inMemoryCountryMap.put(qatarKey, "Qatar");
+
+            LongValue key = Values.newHeapInstance(LongValue.class);
+            key.setValue(1);
+            persistedCountryMap.put(key, "Romania");
+            key.setValue(2);
+            persistedCountryMap.put(key, "India");
+
+            Set<Integer> set1 = new HashSet<>();
+            set1.add(1);
+            set1.add(2);
+            multiMap.put(1, set1);
+
+            Set<Integer> set2 = new HashSet<>();
+            set2.add(3);
+            multiMap.put(2, set2);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void givenGetQuery_whenCalled_shouldReturnResult() {
+        LongValue key = Values.newHeapInstance(LongValue.class);
+        key.setValue(1);
+        CharSequence country = inMemoryCountryMap.get(key);
+        assertThat(country.toString(), is(equalTo("Qatar")));
+    }
+
+    @Test
+    public void givenGetUsingQuery_whenCalled_shouldReturnResult() {
+        LongValue key = Values.newHeapInstance(LongValue.class);
+        StringBuilder country = new StringBuilder();
+        key.setValue(1);
+        persistedCountryMap.getUsing(key, country);
+        assertThat(country.toString(), is(equalTo("Romania")));
+        key.setValue(2);
+        persistedCountryMap.getUsing(key, country);
+        assertThat(country.toString(), is(equalTo("India")));
+    }
+
+    @Test
+    public void  givenMultipleKeyQuery_whenProcessed_shouldChangeTheValue() {
+        try (ExternalMapQueryContext<Integer, Set<Integer>, ?> fistContext = multiMap.queryContext(1)) {
+            try (ExternalMapQueryContext<Integer, Set<Integer>, ?> secondContext = multiMap.queryContext(2)) {
+                fistContext.updateLock()
+                    .lock();
+                secondContext.updateLock()
+                    .lock();
+                MapEntry<Integer, Set<Integer>> firstEntry = fistContext.entry();
+                Set<Integer> firstSet = firstEntry.value()
+                    .get();
+                firstSet.remove(2);
+                MapEntry<Integer, Set<Integer>> secondEntry = secondContext.entry();
+                Set<Integer> secondSet = secondEntry.value()
+                    .get();
+                secondSet.add(4);
+                firstEntry.doReplaceValue(fistContext.wrapValueAsData(firstSet));
+                secondEntry.doReplaceValue(secondContext.wrapValueAsData(secondSet));
+            }
+        } finally {
+            assertThat(multiMap.get(1)
+                .size(), is(equalTo(1)));
+            assertThat(multiMap.get(2)
+                .size(), is(equalTo(2)));
+        }
+    }
+
+    @AfterClass
+    public static void finish() {
+        persistedCountryMap.close();
+        inMemoryCountryMap.close();
+        multiMap.close();
+    }
+}

libraries-2/src/test/java/com/baeldung/classgraph/ClassGraphUnitTest.java

@@ -0,0 +1,74 @@
+package com.baeldung.classgraph;
+
+import io.github.classgraph.*;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.function.Consumer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ClassGraphUnitTest {
+
+    @Test
+    public void whenClassAnnotationFilterIsDefined_thenTargetClassesCanBeFound() {
+        doTest(result -> {
+            ClassInfoList classInfos = result.getClassesWithAnnotation(TestAnnotation.class.getName());
+            assertThat(classInfos).extracting(ClassInfo::getName).contains(ClassWithAnnotation.class.getName());
+        });
+    }
+
+    @Test
+    public void whenMethodAnnotationFilterIsDefined_thenTargetClassesCanBeFound() {
+        doTest(result -> {
+            ClassInfoList classInfos = result.getClassesWithMethodAnnotation(TestAnnotation.class.getName());
+            assertThat(classInfos).extracting(ClassInfo::getName).contains(MethodWithAnnotation.class.getName());
+        });
+    }
+
+    @Test
+    public void whenMethodAnnotationValueFilterIsDefined_thenTargetClassesCanBeFound() {
+        doTest(result -> {
+            ClassInfoList classInfos = result.getClassesWithMethodAnnotation(TestAnnotation.class.getName());
+            ClassInfoList filteredClassInfos = classInfos.filter(classInfo -> {
+                return classInfo.getMethodInfo().stream().anyMatch(methodInfo -> {
+                    AnnotationInfo annotationInfo = methodInfo.getAnnotationInfo(TestAnnotation.class.getName());
+                    if (annotationInfo == null) {
+                        return false;
+                    }
+
+                    return "web".equals(annotationInfo.getParameterValues().getValue("value"));
+                });
+            });
+            assertThat(filteredClassInfos)
+                    .extracting(ClassInfo::getName)
+                    .contains(MethodWithAnnotationParameterWeb.class.getName());
+        });
+    }
+
+    @Test
+    public void whenFieldAnnotationFilterIsDefined_thenTargetClassesCanBeFound() {
+        doTest(result -> {
+            ClassInfoList classInfos = result.getClassesWithFieldAnnotation(TestAnnotation.class.getName());
+            assertThat(classInfos).extracting(ClassInfo::getName).contains(FieldWithAnnotation.class.getName());
+        });
+    }
+
+    @Test
+    public void whenResourceIsUsed_thenItCanBeFoundAndLoaded() throws IOException {
+        try (ScanResult result = new ClassGraph().whitelistPaths("classgraph").scan()) {
+            ResourceList resources = result.getResourcesWithExtension("config");
+            assertThat(resources).extracting(Resource::getPath).containsOnly("classgraph/my.config");
+            assertThat(resources.get(0).getContentAsString()).isEqualTo("my data");
+        }
+    }
+
+    private void doTest(Consumer<ScanResult> checker) {
+        try (ScanResult result = new ClassGraph().enableAllInfo()
+                                                 .whitelistPackages(getClass().getPackage().getName())
+                                                 .scan())
+        {
+            checker.accept(result);
+        }
+    }
+}

libraries-2/src/test/java/com/baeldung/classgraph/ClassWithAnnotation.java

@@ -0,0 +1,5 @@
+package com.baeldung.classgraph;
+
+@TestAnnotation
+public class ClassWithAnnotation {
+}

libraries-2/src/test/java/com/baeldung/classgraph/FieldWithAnnotation.java

@@ -0,0 +1,7 @@
+package com.baeldung.classgraph;
+
+public class FieldWithAnnotation {
+
+    @TestAnnotation
+    private String s;
+}

libraries-2/src/test/java/com/baeldung/classgraph/MethodWithAnnotation.java

@@ -0,0 +1,8 @@
+package com.baeldung.classgraph;
+
+public class MethodWithAnnotation {
+
+    @TestAnnotation
+    public void service() {
+    }
+}

libraries-2/src/test/java/com/baeldung/classgraph/MethodWithAnnotationParameterDao.java

@@ -0,0 +1,8 @@
+package com.baeldung.classgraph;
+
+public class MethodWithAnnotationParameterDao {
+
+    @TestAnnotation("dao")
+    public void service() {
+    }
+}

libraries-2/src/test/java/com/baeldung/classgraph/MethodWithAnnotationParameterWeb.java

@@ -0,0 +1,8 @@
+package com.baeldung.classgraph;
+
+public class MethodWithAnnotationParameterWeb {
+
+    @TestAnnotation("web")
+    public void service() {
+    }
+}

libraries-2/src/test/java/com/baeldung/classgraph/TestAnnotation.java

@@ -0,0 +1,14 @@
+package com.baeldung.classgraph;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.*;
+
+@Target({TYPE, METHOD, FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface TestAnnotation {
+
+    String value() default "";
+}

libraries-2/src/test/java/com/baeldung/handlebars/BasicUsageUnitTest.java

@@ -0,0 +1,109 @@
+package com.baeldung.handlebars;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.github.jknack.handlebars.Handlebars;
+import com.github.jknack.handlebars.Template;
+import com.github.jknack.handlebars.io.ClassPathTemplateLoader;
+import com.github.jknack.handlebars.io.TemplateLoader;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+
+/**
+ * Showcases the tag usage and different template loading mechanisms.
+ *
+ * @author isaolmez
+ */
+public class BasicUsageUnitTest {
+
+    @Test
+    public void whenThereIsNoTemplateFile_ThenCompilesInline() throws IOException {
+        Handlebars handlebars = new Handlebars();
+        Template template = handlebars.compileInline("Hi {{this}}!");
+
+        String templateString = template.apply("Baeldung");
+
+        assertThat(templateString).isEqualTo("Hi Baeldung!");
+    }
+
+    @Test
+    public void whenParameterMapIsSupplied_thenDisplays() throws IOException {
+        Handlebars handlebars = new Handlebars();
+        Template template = handlebars.compileInline("Hi {{name}}!");
+        Map<String, String> parameterMap = new HashMap<>();
+        parameterMap.put("name", "Baeldung");
+
+        String templateString = template.apply(parameterMap);
+
+        assertThat(templateString).isEqualTo("Hi Baeldung!");
+    }
+
+    @Test
+    public void whenParameterObjectIsSupplied_ThenDisplays() throws IOException {
+        Handlebars handlebars = new Handlebars();
+        Template template = handlebars.compileInline("Hi {{name}}!");
+        Person person = new Person();
+        person.setName("Baeldung");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("Hi Baeldung!");
+    }
+
+    @Test
+    public void whenMultipleParametersAreSupplied_ThenDisplays() throws IOException {
+        Handlebars handlebars = new Handlebars();
+        Template template = handlebars.compileInline("Hi {{name}}! This is {{topic}}.");
+        Map<String, String> parameterMap = new HashMap<>();
+        parameterMap.put("name", "Baeldung");
+        parameterMap.put("topic", "Handlebars");
+
+        String templateString = template.apply(parameterMap);
+
+        assertThat(templateString).isEqualTo("Hi Baeldung! This is Handlebars.");
+    }
+
+    @Test
+    public void whenNoLoaderIsGiven_ThenSearchesClasspath() throws IOException {
+        Handlebars handlebars = new Handlebars();
+        Template template = handlebars.compile("greeting");
+        Person person = getPerson("Baeldung");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("Hi Baeldung!");
+    }
+
+    @Test
+    public void whenClasspathTemplateLoaderIsGiven_ThenSearchesClasspathWithPrefixSuffix() throws IOException {
+        TemplateLoader loader = new ClassPathTemplateLoader("/handlebars", ".html");
+        Handlebars handlebars = new Handlebars(loader);
+        Template template = handlebars.compile("greeting");
+        Person person = getPerson("Baeldung");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("Hi Baeldung!");
+    }
+
+    @Test
+    public void whenMultipleLoadersAreGiven_ThenSearchesSequentially() throws IOException {
+        TemplateLoader firstLoader = new ClassPathTemplateLoader("/handlebars", ".html");
+        TemplateLoader secondLoader = new ClassPathTemplateLoader("/templates", ".html");
+        Handlebars handlebars = new Handlebars().with(firstLoader, secondLoader);
+        Template template = handlebars.compile("greeting");
+        Person person = getPerson("Baeldung");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("Hi Baeldung!");
+    }
+
+    private Person getPerson(String name) {
+        Person person = new Person();
+        person.setName(name);
+        return person;
+    }
+}

libraries-2/src/test/java/com/baeldung/handlebars/BuiltinHelperUnitTest.java

@@ -0,0 +1,106 @@
+package com.baeldung.handlebars;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.github.jknack.handlebars.Handlebars;
+import com.github.jknack.handlebars.Template;
+import com.github.jknack.handlebars.io.ClassPathTemplateLoader;
+import com.github.jknack.handlebars.io.TemplateLoader;
+import java.io.IOException;
+import org.junit.Test;
+
+/**
+ * Showcases the built-in template helpers.
+ *
+ * @author isaolmez
+ */
+public class BuiltinHelperUnitTest {
+
+    private TemplateLoader templateLoader = new ClassPathTemplateLoader("/handlebars", ".html");
+
+    @Test
+    public void whenUsedWith_ThenContextChanges() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        Template template = handlebars.compile("with");
+        Person person = getPerson("Baeldung");
+        person.getAddress().setStreet("World");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("\n<h4>I live in World</h4>\n");
+    }
+
+    @Test
+    public void whenUsedWithMustacheStyle_ThenContextChanges() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        Template template = handlebars.compile("with_mustache");
+        Person person = getPerson("Baeldung");
+        person.getAddress().setStreet("World");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("\n<h4>I live in World</h4>\n");
+    }
+
+    @Test
+    public void whenUsedEach_ThenIterates() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        Template template = handlebars.compile("each");
+        Person person = getPerson("Baeldung");
+        Person friend1 = getPerson("Java");
+        Person friend2 = getPerson("Spring");
+        person.getFriends().add(friend1);
+        person.getFriends().add(friend2);
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("\n<span>Java is my friend.</span>\n"
+                                               + "\n<span>Spring is my friend.</span>\n");
+    }
+
+    @Test
+    public void whenUsedEachMustacheStyle_ThenIterates() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        Template template = handlebars.compile("each_mustache");
+        Person person = getPerson("Baeldung");
+        Person friend1 = getPerson("Java");
+        Person friend2 = getPerson("Spring");
+        person.getFriends().add(friend1);
+        person.getFriends().add(friend2);
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("\n<span>Java is my friend.</span>\n"
+                                               + "\n<span>Spring is my friend.</span>\n");
+    }
+
+    @Test
+    public void whenUsedIf_ThenPutsCondition() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        Template template = handlebars.compile("if");
+        Person person = getPerson("Baeldung");
+        person.setBusy(true);
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("\n<h4>Baeldung is busy.</h4>\n");
+    }
+
+    @Test
+    public void whenUsedIfMustacheStyle_ThenPutsCondition() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        Template template = handlebars.compile("if_mustache");
+        Person person = getPerson("Baeldung");
+        person.setBusy(true);
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("\n<h4>Baeldung is busy.</h4>\n");
+    }
+
+    private Person getPerson(String name) {
+        Person person = new Person();
+        person.setName(name);
+        return person;
+    }
+}

libraries-2/src/test/java/com/baeldung/handlebars/CustomHelperUnitTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.handlebars;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.github.jknack.handlebars.Handlebars;
+import com.github.jknack.handlebars.Helper;
+import com.github.jknack.handlebars.Options;
+import com.github.jknack.handlebars.Template;
+import com.github.jknack.handlebars.io.ClassPathTemplateLoader;
+import com.github.jknack.handlebars.io.TemplateLoader;
+import java.io.IOException;
+import org.junit.Test;
+
+/**
+ * Showcases implementing a custom template helper.
+ *
+ * @author isaolmez
+ */
+public class CustomHelperUnitTest {
+
+    private TemplateLoader templateLoader = new ClassPathTemplateLoader("/handlebars", ".html");
+
+    @Test
+    public void whenHelperIsCreated_ThenCanRegister() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        handlebars.registerHelper("isBusy", new Helper<Person>() {
+            @Override
+            public Object apply(Person context, Options options) throws IOException {
+                String busyString = context.isBusy() ? "busy" : "available";
+                return context.getName() + " - " + busyString;
+            }
+        });
+        Template template = handlebars.compile("person");
+        Person person = getPerson("Baeldung");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("Baeldung - busy");
+    }
+
+    @Test
+    public void whenHelperSourceIsCreated_ThenCanRegister() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        handlebars.registerHelpers(new HelperSource());
+        Template template = handlebars.compile("person");
+        Person person = getPerson("Baeldung");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("Baeldung - busy");
+    }
+
+    private Person getPerson(String name) {
+        Person person = new Person();
+        person.setName(name);
+        person.setBusy(true);
+        return person;
+    }
+}

libraries-2/src/test/java/com/baeldung/handlebars/HelperSource.java

@@ -0,0 +1,9 @@
+package com.baeldung.handlebars;
+
+public class HelperSource {
+
+    public String isBusy(Person context) {
+        String busyString = context.isBusy() ? "busy" : "available";
+        return context.getName() + " - " + busyString;
+    }
+}

libraries-2/src/test/java/com/baeldung/handlebars/Person.java

@@ -0,0 +1,58 @@
+package com.baeldung.handlebars;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Person {
+
+    private String name;
+    private boolean busy;
+    private Address address = new Address();
+    private List<Person> friends = new ArrayList<>();
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public boolean isBusy() {
+        return busy;
+    }
+
+    public void setBusy(boolean busy) {
+        this.busy = busy;
+    }
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
+
+    public List<Person> getFriends() {
+        return friends;
+    }
+
+    public void setFriends(List<Person> friends) {
+        this.friends = friends;
+    }
+
+    public static class Address {
+
+        private String street;
+
+        public String getStreet() {
+            return street;
+        }
+
+        public void setStreet(String street) {
+            this.street = street;
+        }
+    }
+
+}

libraries-2/src/test/java/com/baeldung/handlebars/ReusingTemplatesUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.handlebars;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.github.jknack.handlebars.Handlebars;
+import com.github.jknack.handlebars.Template;
+import com.github.jknack.handlebars.io.ClassPathTemplateLoader;
+import com.github.jknack.handlebars.io.TemplateLoader;
+import java.io.IOException;
+import org.junit.Test;
+
+/**
+ * Showcases reusing the existing templates.
+ *
+ * @author isaolmez
+ */
+public class ReusingTemplatesUnitTest {
+
+    private TemplateLoader templateLoader = new ClassPathTemplateLoader("/handlebars", ".html");
+
+    @Test
+    public void whenOtherTemplateIsReferenced_ThenCanReuse() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        Template template = handlebars.compile("page");
+        Person person = new Person();
+        person.setName("Baeldung");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("<h4>Hi Baeldung!</h4>\n<p>This is the page Baeldung</p>");
+    }
+
+    @Test
+    public void whenBlockIsDefined_ThenCanOverrideWithPartial() throws IOException {
+        Handlebars handlebars = new Handlebars(templateLoader);
+        Template template = handlebars.compile("simplemessage");
+        Person person = new Person();
+        person.setName("Baeldung");
+
+        String templateString = template.apply(person);
+
+        assertThat(templateString).isEqualTo("\n<html>\n"
+                                               + "<body>\n"
+                                               + "\n  This is the intro\n\n"
+                                               + "\n  Hi there!\n\n"
+                                               + "</body>\n"
+                                               + "</html>");
+    }
+}

libraries-2/src/test/java/com/baeldung/jbpm/WorkflowEngineIntegrationTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.jbpm;
+
+import org.jbpm.test.JbpmJUnitBaseTestCase;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.kie.api.runtime.KieSession;
+import org.kie.api.runtime.manager.RuntimeEngine;
+import org.kie.api.runtime.manager.RuntimeManager;
+import org.kie.api.runtime.process.ProcessInstance;
+import org.kie.internal.runtime.manager.context.ProcessInstanceIdContext;
+
+public class WorkflowEngineIntegrationTest extends JbpmJUnitBaseTestCase {
+
+    private String[] triggeredNodesArray = { "Start", "HelloWorld", "End" };
+    private RuntimeManager manager = null;
+    private RuntimeEngine runtimeEngine = null;
+    private KieSession ksession = null;
+    private ProcessInstance processInstance = null;
+
+    @Before
+    public void setup() {
+        manager = createRuntimeManager(Strategy.SINGLETON, "manager", "com/baeldung/process/helloworld.bpmn");
+        runtimeEngine = getRuntimeEngine(ProcessInstanceIdContext.get());
+        ksession = runtimeEngine.getKieSession();
+        processInstance = ksession.startProcess("com.baeldung.bpmn.helloworld");
+    }
+
+    @After
+    public void cleanup() {
+        manager.disposeRuntimeEngine(runtimeEngine);
+    }
+
+    @Test
+    public void givenProcessInstance_whenExecutionCompleted_thenVerifyNodesExecutionOrder() {
+        assertNodeTriggered(processInstance.getId(), triggeredNodesArray);
+    }
+
+    @Test
+    public void givenProcessInstance_whenExecutionCompleted_thenVerifyKnowledgeSessionId() {
+        int ksessionID = ksession.getId();
+        runtimeEngine = getRuntimeEngine(ProcessInstanceIdContext.get(processInstance.getId()));
+        ksession = runtimeEngine.getKieSession();
+        assertEquals(ksessionID, ksession.getId());
+    }
+
+    @Test
+    public void givenProcessInstance_whenExecutionCompleted_thenVerifyProcessInstanceStatus() {
+        assertProcessInstanceCompleted(processInstance.getId(), ksession);
+        assertTrue("ProcessInstance completed with status 2", processInstance.getState() == 2);
+    }
+}

libraries-2/src/test/java/com/baeldung/mapdb/CollectionsUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.mapdb;
+
+import org.junit.Test;
+import org.mapdb.DB;
+import org.mapdb.DBMaker;
+import org.mapdb.Serializer;
+
+import java.util.NavigableSet;
+
+import static junit.framework.Assert.assertEquals;
+
+public class CollectionsUnitTest {
+
+    @Test
+    public void givenSetCreatedInDB_whenMultipleElementsAdded_checkOnlyOneExists() {
+
+        DB db = DBMaker.memoryDB().make();
+
+        NavigableSet<String> set = db.
+          treeSet("mySet")
+          .serializer(Serializer.STRING)
+          .createOrOpen();
+
+        String myString = "Baeldung!";
+
+        set.add(myString);
+        set.add(myString);
+
+        assertEquals(1, set.size());
+
+        db.close();
+    }
+}

libraries-2/src/test/java/com/baeldung/mapdb/HTreeMapUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.mapdb;
+
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+import org.mapdb.*;
+
+import java.io.IOException;
+
+import static junit.framework.Assert.assertEquals;
+
+public class HTreeMapUnitTest {
+
+    @Test
+    public void givenValidDB_whenHTreeMapAddedToAndRetrieved_CheckedRetrievalCorrect() {
+
+        DB db = DBMaker.memoryDB().make();
+
+        HTreeMap<String, String> hTreeMap = db
+          .hashMap("myTreMap")
+          .keySerializer(Serializer.STRING)
+          .valueSerializer(Serializer.STRING)
+          .create();
+
+        hTreeMap.put("key1", "value1");
+        hTreeMap.put("key2", "value2");
+
+        assertEquals(2, hTreeMap.size());
+
+        //add another value with the same key
+
+        hTreeMap.put("key1", "value3");
+
+        assertEquals(2, hTreeMap.size());
+        assertEquals("value3", hTreeMap.get("key1"));
+
+    }
+
+}

libraries-2/src/test/java/com/baeldung/mapdb/HelloBaeldungUnitTest.java

@@ -0,0 +1,49 @@
+package com.baeldung.mapdb;
+
+import org.junit.Test;
+import org.mapdb.DB;
+import org.mapdb.DBMaker;
+import org.mapdb.HTreeMap;
+
+import java.util.concurrent.ConcurrentMap;
+
+import static junit.framework.Assert.assertEquals;
+
+public class HelloBaeldungUnitTest {
+
+    @Test
+    public void givenInMemoryDBInstantiateCorrectly_whenDataSavedAndRetrieved_checkRetrievalCorrect() {
+
+        DB db = DBMaker.memoryDB().make();
+
+        String welcomeMessageKey = "Welcome Message";
+        String welcomeMessageString = "Hello Baeldung!";
+
+        HTreeMap myMap = db.hashMap("myMap").createOrOpen();
+        myMap.put(welcomeMessageKey, welcomeMessageString);
+
+        String welcomeMessageFromDB = (String) myMap.get(welcomeMessageKey);
+
+        db.close();
+
+        assertEquals(welcomeMessageString, welcomeMessageFromDB);
+    }
+
+    @Test
+    public void givenInFileDBInstantiateCorrectly_whenDataSavedAndRetrieved_checkRetrievalCorrect() {
+
+        DB db = DBMaker.fileDB("file.db").make();
+
+        String welcomeMessageKey = "Welcome Message";
+        String welcomeMessageString = "Hello Baeldung!";
+
+        HTreeMap myMap = db.hashMap("myMap").createOrOpen();
+        myMap.put(welcomeMessageKey, welcomeMessageString);
+
+        String welcomeMessageFromDB = (String) myMap.get(welcomeMessageKey);
+
+        db.close();
+
+        assertEquals(welcomeMessageString, welcomeMessageFromDB);
+    }
+}

libraries-2/src/test/java/com/baeldung/mapdb/InMemoryModesUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.mapdb;
+
+import org.junit.Test;
+import org.mapdb.DB;
+import org.mapdb.DBMaker;
+import org.mapdb.HTreeMap;
+import org.mapdb.Serializer;
+
+import static junit.framework.Assert.assertEquals;
+
+public class InMemoryModesUnitTest {
+
+    @Test
+    public void givenDBCreatedOnHeap_whenUsed_checkUsageCorrect() {
+
+        DB heapDB = DBMaker.heapDB().make();
+
+        HTreeMap<Integer, String> map = heapDB
+          .hashMap("myMap")
+          .keySerializer(Serializer.INTEGER)
+          .valueSerializer(Serializer.STRING)
+          .createOrOpen();
+
+        map.put(1, "ONE");
+
+        assertEquals("ONE", map.get(1));
+
+    }
+
+    @Test
+    public void givenDBCreatedBaseOnByteArray_whenUsed_checkUsageCorrect() {
+
+        DB heapDB = DBMaker.memoryDB().make();
+
+        HTreeMap<Integer, String> map = heapDB
+          .hashMap("myMap")
+          .keySerializer(Serializer.INTEGER)
+          .valueSerializer(Serializer.STRING)
+          .createOrOpen();
+
+        map.put(1, "ONE");
+
+        assertEquals("ONE", map.get(1));
+    }
+
+    @Test
+    public void givenDBCreatedBaseOnDirectByteBuffer_whenUsed_checkUsageCorrect() {
+
+        DB heapDB = DBMaker.memoryDirectDB().make();
+
+        HTreeMap<Integer, String> map = heapDB
+          .hashMap("myMap")
+          .keySerializer(Serializer.INTEGER)
+          .valueSerializer(Serializer.STRING)
+          .createOrOpen();
+
+        map.put(1, "ONE");
+
+        assertEquals("ONE", map.get(1));
+    }
+
+}

libraries-2/src/test/java/com/baeldung/mapdb/SortedTableMapUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.mapdb;
+
+import org.junit.Test;
+import org.mapdb.Serializer;
+import org.mapdb.SortedTableMap;
+import org.mapdb.volume.MappedFileVol;
+import org.mapdb.volume.Volume;
+
+import static junit.framework.Assert.assertEquals;
+
+public class SortedTableMapUnitTest {
+
+    private static final String VOLUME_LOCATION = "sortedTableMapVol.db";
+
+    @Test
+    public void givenValidSortedTableMapSetup_whenQueried_checkValuesCorrect() {
+
+        //create memory mapped volume, readonly false
+        Volume vol = MappedFileVol.FACTORY.makeVolume(VOLUME_LOCATION, false);
+
+        //create sink to feed the map with data
+        SortedTableMap.Sink<Integer, String> sink =
+          SortedTableMap.create(
+            vol,
+            Serializer.INTEGER,
+            Serializer.STRING
+          ).createFromSink();
+
+        //add content
+        for(int i = 0; i < 100; i++){
+          sink.put(i, "Value " + Integer.toString(i));
+        }
+
+        sink.create();
+
+        //now open in read-only mode
+        Volume openVol = MappedFileVol.FACTORY.makeVolume(VOLUME_LOCATION, true);
+
+        SortedTableMap<Integer, String> sortedTableMap = SortedTableMap.open(
+          openVol,
+          Serializer.INTEGER,
+          Serializer.STRING
+        );
+
+        assertEquals(100, sortedTableMap.size());
+    }
+}

libraries-2/src/test/java/com/baeldung/mapdb/TransactionsUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.mapdb;
+
+import org.junit.Test;
+import org.mapdb.DB;
+import org.mapdb.DBMaker;
+import org.mapdb.Serializer;
+
+import java.util.NavigableSet;
+
+import static junit.framework.Assert.assertEquals;
+
+public class TransactionsUnitTest {
+
+    @Test
+    public void givenValidDBSetup_whenTransactionCommittedAndRolledBack_checkPreviousStateAchieved() {
+
+        DB db = DBMaker.memoryDB().transactionEnable().make();
+
+        NavigableSet<String> set = db
+          .treeSet("mySet")
+          .serializer(Serializer.STRING)
+          .createOrOpen();
+
+        set.add("One");
+        set.add("Two");
+
+        db.commit();
+
+        assertEquals(2, set.size());
+
+        set.add("Three");
+
+        assertEquals(3, set.size());
+
+        db.rollback();
+
+        assertEquals(2, set.size());
+
+        db.close();
+    }
+}

libraries-2/src/test/java/com/baeldung/okhttp/ResponseDecoderUnitTest.java

@@ -0,0 +1,102 @@
+package com.baeldung.okhttp;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.gson.Gson;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import okhttp3.ResponseBody;
+import okhttp3.mockwebserver.MockResponse;
+import okhttp3.mockwebserver.MockWebServer;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.io.InputStreamReader;
+
+public class ResponseDecoderUnitTest {
+
+    @Rule public ExpectedException exceptionRule = ExpectedException.none();
+
+    @Rule public MockWebServer server = new MockWebServer();
+
+    SimpleEntity sampleResponse;
+
+    MockResponse mockResponse;
+
+    OkHttpClient client;
+
+    @Before
+    public void setUp() {
+        sampleResponse = new SimpleEntity("Baeldung");
+        client = new OkHttpClient.Builder().build();
+        mockResponse = new MockResponse()
+          .setResponseCode(200)
+          .setHeader("Content-Type", "application/json")
+          .setBody(new Gson().toJson(sampleResponse));
+    }
+
+    @Test
+    public void givenJacksonDecoder_whenGetStringOfResponse_thenExpectSimpleEntity() throws Exception {
+        server.enqueue(mockResponse);
+        Request request = new Request.Builder()
+          .url(server.url(""))
+          .build();
+        ResponseBody responseBody = client
+          .newCall(request)
+          .execute()
+          .body();
+
+        Assert.assertNotNull(responseBody);
+        Assert.assertNotEquals(0, responseBody.contentLength());
+
+        ObjectMapper objectMapper = new ObjectMapper();
+        SimpleEntity entity = objectMapper.readValue(responseBody.string(), SimpleEntity.class);
+
+        Assert.assertNotNull(entity);
+        Assert.assertEquals(sampleResponse.getName(), entity.getName());
+    }
+
+    @Test
+    public void givenGsonDecoder_whenGetByteStreamOfResponse_thenExpectSimpleEntity() throws Exception {
+        server.enqueue(mockResponse);
+        Request request = new Request.Builder()
+          .url(server.url(""))
+          .build();
+        ResponseBody responseBody = client
+          .newCall(request)
+          .execute()
+          .body();
+
+        Assert.assertNotNull(responseBody);
+        Assert.assertNotEquals(0, responseBody.contentLength());
+
+        Gson gson = new Gson();
+        SimpleEntity entity = gson.fromJson(new InputStreamReader(responseBody.byteStream()), SimpleEntity.class);
+
+        Assert.assertNotNull(entity);
+        Assert.assertEquals(sampleResponse.getName(), entity.getName());
+    }
+
+    @Test
+    public void givenGsonDecoder_whenGetStringOfResponse_thenExpectSimpleEntity() throws Exception {
+        server.enqueue(mockResponse);
+        Request request = new Request.Builder()
+          .url(server.url(""))
+          .build();
+        ResponseBody responseBody = client
+          .newCall(request)
+          .execute()
+          .body();
+
+        Assert.assertNotNull(responseBody);
+
+        Gson gson = new Gson();
+        SimpleEntity entity = gson.fromJson(responseBody.string(), SimpleEntity.class);
+
+        Assert.assertNotNull(entity);
+        Assert.assertEquals(sampleResponse.getName(), entity.getName());
+    }
+
+}

libraries-2/src/test/java/com/baeldung/okhttp/SimpleEntity.java

@@ -0,0 +1,22 @@
+package com.baeldung.okhttp;
+
+public class SimpleEntity {
+    protected String name;
+
+    public SimpleEntity(String name) {
+        this.name = name;
+    }
+
+    //no-arg constructor, getters and setters here
+    
+    public SimpleEntity() {
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

libraries-2/src/test/java/com/baeldung/parallel_collectors/ParallelCollectorsUnitTest.java

@@ -0,0 +1,168 @@
+package com.baeldung.parallel_collectors;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.Collectors;
+
+import static com.pivovarit.collectors.ParallelCollectors.parallel;
+import static com.pivovarit.collectors.ParallelCollectors.parallelOrdered;
+import static com.pivovarit.collectors.ParallelCollectors.parallelToCollection;
+import static com.pivovarit.collectors.ParallelCollectors.parallelToList;
+import static com.pivovarit.collectors.ParallelCollectors.parallelToMap;
+import static com.pivovarit.collectors.ParallelCollectors.parallelToStream;
+
+public class ParallelCollectorsUnitTest {
+
+    @Test
+    public void shouldProcessInParallelWithStreams() {
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        List<String> results = ids.parallelStream()
+          .map(i -> fetchById(i))
+          .collect(Collectors.toList());
+
+        System.out.println(results);
+    }
+
+    @Test
+    public void shouldProcessInParallelWithParallelCollectors() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        CompletableFuture<List<String>> results = ids.stream()
+          .collect(parallelToList(i -> fetchById(i), executor, 4));
+
+        System.out.println(results.join());
+    }
+
+    @Test
+    public void shouldCollectToList() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        List<String> results = ids.stream()
+          .collect(parallelToList(i -> fetchById(i), executor, 4))
+          .join();
+
+        System.out.println(results); // [user-1, user-2, user-3]
+    }
+
+    @Test
+    public void shouldCollectToCollection() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        List<String> results = ids.stream()
+          .collect(parallelToCollection(i -> fetchById(i), LinkedList::new, executor, 4))
+          .join();
+
+        System.out.println(results); // [user-1, user-2, user-3]
+    }
+
+    @Test
+    public void shouldCollectToStream() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        Map<Integer, List<String>> results = ids.stream()
+          .collect(parallelToStream(i -> fetchById(i), executor, 4))
+          .thenApply(stream -> stream.collect(Collectors.groupingBy(i -> i.length())))
+          .join();
+
+        System.out.println(results); // [user-1, user-2, user-3]
+    }
+
+    @Test
+    public void shouldStreamInCompletionOrder() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        ids.stream()
+          .collect(parallel(i -> fetchByIdWithRandomDelay(i), executor, 4))
+          .forEach(System.out::println);
+    }
+
+    @Test
+    public void shouldStreamInOriginalOrder() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        ids.stream()
+          .collect(parallelOrdered(i -> fetchByIdWithRandomDelay(i), executor, 4))
+          .forEach(System.out::println);
+    }
+
+    @Test
+    public void shouldCollectToMap() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        Map<Integer, String> results = ids.stream()
+          .collect(parallelToMap(i -> i, i -> fetchById(i), executor, 4))
+          .join();
+
+        System.out.println(results); // {1=user-1, 2=user-2, 3=user-3}
+    }
+
+    @Test
+    public void shouldCollectToTreeMap() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        Map<Integer, String> results = ids.stream()
+          .collect(parallelToMap(i -> i, i -> fetchById(i), TreeMap::new,  executor, 4))
+          .join();
+
+        System.out.println(results); // {1=user-1, 2=user-2, 3=user-3}
+    }
+
+    @Test
+    public void shouldCollectToTreeMapAndResolveClashes() {
+        ExecutorService executor = Executors.newFixedThreadPool(10);
+
+        List<Integer> ids = Arrays.asList(1, 2, 3);
+
+        Map<Integer, String> results = ids.stream()
+          .collect(parallelToMap(i -> i, i -> fetchById(i), TreeMap::new, (s1, s2) -> s1,   executor, 4))
+          .join();
+
+        System.out.println(results); // {1=user-1, 2=user-2, 3=user-3}
+    }
+
+    private static String fetchById(int id) {
+        try {
+            Thread.sleep(100);
+        } catch (InterruptedException e) {
+            // ignore shamelessly
+        }
+
+        return "user-" + id;
+    }
+
+    private static String fetchByIdWithRandomDelay(int id) {
+        try {
+            Thread.sleep(ThreadLocalRandom.current().nextInt(1000));
+        } catch (InterruptedException e) {
+            // ignore shamelessly
+        }
+
+        return "user-" + id;
+    }
+}