Merge remote-tracking branch 'Baeldung/master' into active_mq

# Conflicts: # .gitignore # LICENSE # README.md # core-java-modules/README.md # core-java-modules/core-java-11/README.md # core-java-modules/core-java-11/pom.xml # core-java-modules/core-java-8/README.md # core-java-modules/core-java-8/pom.xml # core-java-modules/core-java-8/src/main/resources/logback.xml # core-java-modules/core-java-annotations/README.md # core-java-modules/core-java-annotations/pom.xml # core-java-modules/core-java-collections-2/README.md # core-java-modules/core-java-collections-2/pom.xml # core-java-modules/core-java-collections-3/README.md # core-java-modules/core-java-collections-3/pom.xml # core-java-modules/core-java-collections-conversions-2/README.md # core-java-modules/core-java-collections-conversions-2/pom.xml # core-java-modules/core-java-collections-conversions/README.md # core-java-modules/core-java-collections-conversions/pom.xml # core-java-modules/core-java-collections-list/README.md # core-java-modules/core-java-collections-list/pom.xml # core-java-modules/core-java-collections/pom.xml # core-java-modules/core-java-datetime-conversion/README.md # core-java-modules/core-java-datetime-conversion/pom.xml # core-java-modules/core-java-datetime-conversion/src/test/java/com/baeldung/datetime/ConvertInstantToTimestampUnitTest.java # core-java-modules/core-java-io-2/pom.xml # core-java-modules/core-java-io/README.md # core-java-modules/core-java-io/pom.xml # core-java-modules/core-java-io/src/test/resources/fileTest.txt # core-java-modules/core-java-io/src/test/resources/sampleTextFile.txt # core-java-modules/core-java-lambdas/README.md # core-java-modules/core-java-lambdas/pom.xml # core-java-modules/core-java-serialization/pom.xml # core-java-modules/core-java-streams/README.md # core-java-modules/core-java-streams/pom.xml # core-java-modules/core-java-strings/README.md # core-java-modules/core-java-strings/pom.xml # core-java-modules/core-java-strings/src/test/resources/stringtoolong.txt # core-java-modules/core-java-uuid/README.md # core-java-modules/core-java-uuid/pom.xml # core-java-modules/pom.xml # image-processing/README.md # image-processing/pom.xml # image-processing/src/main/java/com/baeldung/imageprocessing/addingtext/AddText.java # image-processing/src/main/java/com/baeldung/imageprocessing/opencv/CameraStream.java # jackson-modules/jackson-annotations/README.md # jackson-modules/jackson-annotations/pom.xml # jackson-modules/jackson-conversions-2/README.md # jackson-modules/jackson-conversions-2/pom.xml # jackson-modules/jackson-conversions/README.md # jackson-modules/jackson-conversions/pom.xml # jackson-modules/jackson-custom-conversions/README.md # jackson-modules/jackson-custom-conversions/pom.xml # jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/defaultserializercustomserializer/CallingDefaultSerializerUnitTest.java # jackson-modules/jackson-custom-conversions/src/test/java/com/baeldung/deserialization/CustomDeserializationUnitTest.java # jackson-modules/jackson-exceptions/README.md # jackson-modules/jackson-exceptions/pom.xml # jackson-modules/jackson-exceptions/src/test/java/com/baeldung/exceptions/JacksonExceptionsUnitTest.java # jackson-modules/jackson-exceptions/src/test/java/com/baeldung/mappingexception/JacksonMappingExceptionUnitTest.java # jackson-modules/pom.xml # parent-boot-1/pom.xml # parent-boot-2/pom.xml # parent-boot-3/pom.xml # patterns-modules/design-patterns-architectural/pom.xml # patterns-modules/design-patterns-architectural/src/main/java/com/baeldung/repositoryvsdaopattern/UserDaoImpl.java # patterns-modules/design-patterns-behavioral-2/README.md # patterns-modules/design-patterns-behavioral-2/pom.xml # patterns-modules/design-patterns-creational-2/README.md # patterns-modules/design-patterns-creational-2/pom.xml # patterns-modules/design-patterns-singleton/README.md # patterns-modules/design-patterns-structural/src/main/resources/log4jstructuraldp.properties # patterns-modules/enterprise-patterns/pom.xml # patterns-modules/intercepting-filter/pom.xml # patterns-modules/pom.xml # persistence-modules/activejdbc/pom.xml # persistence-modules/hibernate5/README.md # persistence-modules/hibernate5/pom.xml # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/CustomInterceptor.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/interceptors/entity/User.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/namingstrategy/CustomPhysicalNamingStrategy.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/Customer.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/persistjson/HashMapConverter.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryIdClass.java # persistence-modules/hibernate5/src/main/java/com/baeldung/hibernate/pojo/OrderEntryPK.java # persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/IdentifiersIntegrationTest.java # persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/bootstrap/BootstrapAPIIntegrationTest.java # persistence-modules/hibernate5/src/test/java/com/baeldung/hibernate/proxy/HibernateProxyUnitTest.java # persistence-modules/hibernate5/src/test/resources/hibernate-interceptors.properties # persistence-modules/hibernate5/src/test/resources/hibernate-lifecycle.properties # persistence-modules/hibernate5/src/test/resources/hibernate-namingstrategy.properties # persistence-modules/hibernate5/src/test/resources/hibernate-persistjson.properties # persistence-modules/hibernate5/src/test/resources/hibernate.properties # persistence-modules/pom.xml # persistence-modules/spring-data-jpa-crud/pom.xml # persistence-modules/spring-data-jpa-crud/src/main/java/com/baeldung/repository/FruitRepository.java # persistence-modules/spring-data-jpa-repo-2/README.md # persistence-modules/spring-data-jpa-repo-2/pom.xml # persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/model/User.java # persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/customrepository/repository/CustomUserRepositoryImpl.java # persistence-modules/spring-data-jpa-repo-2/src/main/java/com/baeldung/spring/data/persistence/saveperformance/Book.java # persistence-modules/spring-data-jpa-repo-2/src/main/resources/application.properties # persistence-modules/spring-data-mongodb-reactive/pom.xml # persistence-modules/spring-data-redis/README.md # persistence-modules/spring-data-redis/pom.xml # persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/reactive/redis/config/RedisConfig.java # persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/config/RedisConfig.java # persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/model/Student.java # persistence-modules/spring-data-redis/src/main/java/com/baeldung/spring/data/redis/queue/RedisMessageSubscriber.java # persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisKeyCommandsManualTest.java # persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateListOpsManualTest.java # persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/reactive/redis/template/RedisTemplateValueOpsManualTest.java # persistence-modules/spring-data-redis/src/test/java/com/baeldung/spring/data/redis/repo/StudentRepositoryManualTest.java # pom.xml # testing-modules/assertion-libraries/README.md # testing-modules/assertion-libraries/pom.xml # testing-modules/junit-5-basics/README.md # testing-modules/junit-5-basics/pom.xml # testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Helper.java # testing-modules/mockito-2/src/main/java/com/baeldung/nullmatcher/Main.java # testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Helper.java # testing-modules/mockito-2/src/main/java/com/baeldung/wantedbutnotinvocked/Main.java # testing-modules/mockito-2/src/test/java/com/baeldung/nullmatcher/MainUnitTest.java # testing-modules/mockito-2/src/test/java/com/baeldung/wantedbutnotinvocked/MainUnitTest.java # testing-modules/pom.xml # testing-modules/spring-mockito/pom.xml # web-modules/dropwizard/pom.xml # web-modules/jakarta-ee/README.md # web-modules/jakarta-ee/pom.xml # web-modules/jakarta-ee/src/test/java/com/baeldung/eclipse/krazo/UserControllerUnitTest.java # web-modules/java-lite/pom.xml # web-modules/javax-servlets-2/README.md # web-modules/javax-servlets-2/pom.xml # web-modules/javax-servlets/pom.xml # web-modules/jee-7/pom.xml # web-modules/jooby/pom.xml # web-modules/ninja/pom.xml # web-modules/pom.xml # web-modules/ratpack/pom.xml # web-modules/resteasy/pom.xml # web-modules/restx/pom.xml # web-modules/spark-java/pom.xml # web-modules/vraptor/pom.xml # xml/README.md # xml/pom.xml # xml/src/main/resources/customer-binding.xml # xml/src/main/resources/sax/baeldung.xml # xml/src/test/resources/example_default_parser.xml # xml/src/test/resources/example_dom4j.xml # xml/src/test/resources/example_jaxb.xml # xml/src/test/resources/example_jaxen.xml # xml/src/test/resources/example_jdom.xml # xml/src/test/resources/example_stax.xml # xml/src/test/resources/sax/baeldung.xml # xml/src/test/resources/xml/websites.xml # xml/src/test/resources/xml/xee_attribute.xml
2024-04-30 12:23:19 -04:00
parent c18eb6d2ed 8cabe509a5
commit a51b7b55d9
27985 changed files with 1584039 additions and 0 deletions
@@ -0,0 +1,14 @@
+## Core Java 10
+
+This module contains articles about Java 10 core features
+
+### Relevant Articles: 
+
+- [Java 10 LocalVariable Type-Inference](http://www.baeldung.com/java-10-local-variable-type-inference)
+- [New Features in Java 10](https://www.baeldung.com/java-10-overview)
+- [Copy a List to Another List in Java](http://www.baeldung.com/java-copy-list-to-another)
+- [Deep Dive Into the New Java JIT Compiler – Graal](https://www.baeldung.com/graal-java-jit-compiler)
+- [Copying Sets in Java](https://www.baeldung.com/java-copy-sets)
+- [Converting Between a List and a Set in Java](https://www.baeldung.com/convert-list-to-set-and-set-to-list)
+- [Java IndexOutOfBoundsException “Source Does Not Fit in Dest”](https://www.baeldung.com/java-indexoutofboundsexception)
+- [Collect a Java Stream to an Immutable Collection](https://www.baeldung.com/java-stream-immutable-collection)
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-10</artifactId>
+    <packaging>jar</packaging>
+    <name>core-java-10</name>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>${commons-collections4.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>${maven.compiler.source.version}</source>
+                    <target>${maven.compiler.target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source.version>10</maven.compiler.source.version>
+        <maven.compiler.target.version>10</maven.compiler.target.version>
+    </properties>
+
+</project>
@@ -0,0 +1,13 @@
+package com.baeldung;
+
+/**
+ * Hello world!
+ *
+ */
+public class App 
+{
+    public static void main( String[] args )
+    {
+        System.out.println( "Hello World!" );
+    }
+}
@@ -0,0 +1,25 @@
+package com.baeldung.graal;
+
+public class CountUppercase {
+    static final int ITERATIONS = Math.max(Integer.getInteger("iterations", 1), 1);
+
+    public static void main(String[] args) {
+        String sentence = String.join(" ", args);
+        for (int iter = 0; iter < ITERATIONS; iter++) {
+            if (ITERATIONS != 1) System.out.println("-- iteration " + (iter + 1) + " --");
+            long total = 0, start = System.currentTimeMillis(), last = start;
+            for (int i = 1; i < 10_000_000; i++) {
+                total += sentence
+                  .chars()
+                  .filter(Character::isUpperCase)
+                  .count();
+                if (i % 1_000_000 == 0) {
+                    long now = System.currentTimeMillis();
+                    System.out.printf("%d (%d ms)%n", i / 1_000_000, now - last);
+                    last = now;
+                }
+            }
+            System.out.printf("total: %d (%d ms)%n", total, System.currentTimeMillis() - start);
+        }
+    }
+}
@@ -0,0 +1,13 @@
+package com.baeldung.set;
+
+import java.util.Set;
+
+public class CopySets {
+
+    // Using Java 10
+    public static <T> Set<T> copyBySetCopyOf(Set<T> original) {
+        Set<T> copy = Set.copyOf(original);
+        return copy;
+    }
+
+}
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>
@@ -0,0 +1,38 @@
+package com.baeldung;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppUnitTest
+    extends TestCase
+{
+    /**
+     * Create the test case
+     *
+     * @param testName name of the test case
+     */
+    public AppUnitTest(String testName )
+    {
+        super( testName );
+    }
+
+    /**
+     * @return the suite of tests being tested
+     */
+    public static Test suite()
+    {
+        return new TestSuite( AppUnitTest.class );
+    }
+
+    /**
+     * Rigourous Test :-)
+     */
+    public void testApp()
+    {
+        assertTrue( true );
+    }
+}
@@ -0,0 +1,61 @@
+package com.baeldung.java10;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class Java10FeaturesUnitTest {
+
+    private List<Integer> someIntList;
+    
+    @Before
+    public void setup() {
+        someIntList = new ArrayList<>();
+        
+        someIntList.add(1);
+        someIntList.add(2);
+        someIntList.add(3);
+    }
+
+    @Test
+    public void whenVarInitWithString_thenGetStringTypeVar() {
+        var message = "Hello, Java 10";
+        assertTrue(message instanceof String);
+    }
+
+    @Test
+    public void whenVarInitWithAnonymous_thenGetAnonymousType() {
+        var obj = new Object() {};
+        assertFalse(obj.getClass().equals(Object.class));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void whenModifyCopyOfList_thenThrowsException() {
+        List<Integer> copyList = List.copyOf(someIntList);
+        copyList.add(4);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void whenModifyToUnmodifiableList_thenThrowsException() {
+        List<Integer> evenList = someIntList.stream()
+          .filter(i -> i % 2 == 0)
+          .collect(Collectors.toUnmodifiableList());
+        evenList.add(4);
+    }
+
+    @Test
+    public void whenListContainsInteger_OrElseThrowReturnsInteger() {
+        Integer firstEven = someIntList.stream()
+          .filter(i -> i % 2 == 0)
+          .findFirst()
+          .orElseThrow();
+        is(firstEven).equals(Integer.valueOf(2));
+    }
+}
@@ -0,0 +1,68 @@
+package com.baeldung.java10.collections.conversion;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import org.apache.commons.collections4.CollectionUtils;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class ListSetConversionUnitTest {
+
+    // Set -> List; List -> Set
+
+    @Test
+    public final void givenUsingCoreJava_whenSetConvertedToList_thenCorrect() {
+        final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
+        final List<Integer> targetList = new ArrayList<>(sourceSet);
+    }
+
+    @Test
+    public final void givenUsingCoreJava_whenListConvertedToSet_thenCorrect() {
+        final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
+        final Set<Integer> targetSet = new HashSet<>(sourceList);
+    }
+
+    @Test
+    public void givenUsingJava10_whenSetConvertedToList_thenCorrect() {
+        final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
+        final List<Integer> targetList = List.copyOf(sourceSet);
+    }
+
+    @Test
+    public void givenUsingJava10_whenListConvertedToSet_thenCorrect() {
+        final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
+        final Set<Integer> targetSet = Set.copyOf(sourceList);
+    }
+
+    @Test
+    public final void givenUsingGuava_whenSetConvertedToList_thenCorrect() {
+        final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
+        final List<Integer> targetList = Lists.newArrayList(sourceSet);
+    }
+
+    @Test
+    public final void givenUsingGuava_whenListConvertedToSet_thenCorrect() {
+        final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
+        final Set<Integer> targetSet = Sets.newHashSet(sourceList);
+    }
+
+    @Test
+    public final void givenUsingCommonsCollections_whenListConvertedToSet_thenCorrect() {
+        final List<Integer> sourceList = Lists.newArrayList(0, 1, 2, 3, 4, 5);
+
+        final Set<Integer> targetSet = new HashSet<>(6);
+        CollectionUtils.addAll(targetSet, sourceList);
+    }
+
+    @Test
+    public final void givenUsingCommonsCollections_whenSetConvertedToList_thenCorrect() {
+        final Set<Integer> sourceSet = Sets.newHashSet(0, 1, 2, 3, 4, 5);
+
+        final List<Integer> targetList = new ArrayList<>(6);
+        CollectionUtils.addAll(targetList, sourceSet);
+    }
+}
@@ -0,0 +1,15 @@
+package com.baeldung.java10.list;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class CopyListServiceUnitTest {
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void whenModifyCopyOfList_thenThrowsException() {
+        List<Integer> copyList = List.copyOf(Arrays.asList(1, 2, 3, 4));
+        copyList.add(4);
+    }
+}
@@ -0,0 +1,20 @@
+package com.baeldung.java10.streams;
+
+import static java.util.stream.Collectors.toUnmodifiableList;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+
+public class StreamToImmutableJava10UnitTest {
+
+    @Test
+    public void whenUsingCollectorsToUnmodifiableList_thenSuccess() {
+        List<String> givenList = Arrays.asList("a", "b", "c");
+        List<String> result = givenList.stream()
+            .collect(toUnmodifiableList());
+
+        System.out.println(result.getClass());
+    }
+}
@@ -0,0 +1,14 @@
+## Core Java 11
+
+This module contains articles about Java 11 core features
+
+### Relevant articles
+- [Guide To Java 8 Optional](https://www.baeldung.com/java-optional)
+- [Guide to Java Reflection](http://www.baeldung.com/java-reflection)
+- [New Features in Java 11](https://www.baeldung.com/java-11-new-features)
+- [Getting the Java Version at Runtime](https://www.baeldung.com/get-java-version-runtime)
+- [Invoking a SOAP Web Service in Java](https://www.baeldung.com/java-soap-web-service)
+- [Java HTTPS Client Certificate Authentication](https://www.baeldung.com/java-https-client-certificate-authentication)
+- [Call Methods at Runtime Using Java Reflection](https://www.baeldung.com/java-method-reflection)
+- [Java HttpClient Basic Authentication](https://www.baeldung.com/java-httpclient-basic-auth)
+- [Java HttpClient With SSL](https://www.baeldung.com/java-httpclient-ssl)
@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-11-2</artifactId>
+    <packaging>jar</packaging>
+    <name>core-java-11-2</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.mock-server</groupId>
+            <artifactId>mockserver-junit-jupiter</artifactId>
+            <version>${mockserver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.xml.ws</groupId>
+            <artifactId>jakarta.xml.ws-api</artifactId>
+            <version>${jakarta.ws-api.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source.version}</source>
+                    <target>${maven.compiler.target.version}</target>
+                </configuration>
+            </plugin>
+            <!-- jax-ws maven plugin -->
+            <plugin>
+                <groupId>com.sun.xml.ws</groupId>
+                <artifactId>jaxws-maven-plugin</artifactId>
+                <version>${jaxws-maven-plugin.version}</version>
+                <configuration>
+                    <wsdlUrls>
+                        <wsdlUrl>http://localhost:8888/ws/country?wsdl</wsdlUrl>
+                    </wsdlUrls>
+                    <keep>true</keep>
+                    <packageName>com.baeldung.soap.ws.client.generated</packageName>
+                    <sourceDestDir>src/main/java</sourceDestDir>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source.version>11</maven.compiler.source.version>
+        <maven.compiler.target.version>11</maven.compiler.target.version>
+        <mockserver.version>5.11.1</mockserver.version>
+        <jakarta.ws-api.version>3.0.1</jakarta.ws-api.version>
+        <jaxws-maven-plugin.version>3.0.2</jaxws-maven-plugin.version>
+    </properties>
+
+</project>
@@ -0,0 +1,17 @@
+package com.baeldung.features;
+
+public class MainClass {
+
+    private static boolean mainPrivateMethod() {
+        return true;
+    }
+
+    public static class NestedClass {
+
+        boolean nestedPublicMethod() {
+            return mainPrivateMethod();
+        }
+
+    }
+
+}
@@ -0,0 +1,67 @@
+package com.baeldung.httpclient.basicauthentication;
+
+import java.io.IOException;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.util.Base64;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class HttpClientBasicAuthentication {
+
+    private static final Logger logger = LoggerFactory.getLogger(HttpClientBasicAuthentication.class);
+
+    public static void main(String[] args) throws URISyntaxException, IOException, InterruptedException {
+        useClientWithAuthenticator();
+        useClientWithHeaders();
+    }
+
+    private static void useClientWithAuthenticator() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient.newBuilder()
+            .authenticator(new Authenticator() {
+                @Override
+                protected PasswordAuthentication getPasswordAuthentication() {
+                    return new PasswordAuthentication("postman", "password".toCharArray());
+                }
+            })
+            .build();
+
+        HttpRequest request = HttpRequest.newBuilder()
+            .GET()
+            .uri(new URI("https://postman-echo.com/basic-auth"))
+            .build();
+
+        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
+
+        logger.info("Status using authenticator {}", response.statusCode());
+    }
+
+    private static void useClientWithHeaders() throws IOException, InterruptedException, URISyntaxException {
+        HttpClient client = HttpClient.newBuilder()
+            .build();
+
+        HttpRequest request = HttpRequest.newBuilder()
+            .GET()
+            .uri(new URI("https://postman-echo.com/basic-auth"))
+            .header("Authorization", getBasicAuthenticationHeader("postman", "password"))
+            .build();
+
+        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
+
+        logger.info("Status using headers: {}", response.statusCode());
+    }
+
+    private static final String getBasicAuthenticationHeader(String username, String password) {
+        String valueToEncode = username + ":" + password;
+        return "Basic " + Base64.getEncoder()
+            .encodeToString(valueToEncode.getBytes());
+    }
+
+}
@@ -0,0 +1,41 @@
+package com.baeldung.httpsclientauthentication;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import javax.net.SocketFactory;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+public class SSLScocketClient {
+
+    static void startClient(String host, int port) throws IOException {
+
+        SocketFactory factory = SSLSocketFactory.getDefault();
+
+        try (SSLSocket socket = (SSLSocket) factory.createSocket(host, port)) {
+            socket.setEnabledCipherSuites(new String[] { "TLS_AES_128_GCM_SHA256" });
+            socket.setEnabledProtocols(new String[] { "TLSv1.3" });
+            InputStream is = new BufferedInputStream(socket.getInputStream());
+            String message = "Hello World Message";
+            System.out.println("sending message: " + message);
+            OutputStream os = new BufferedOutputStream(socket.getOutputStream());
+            os.write(message.getBytes());
+            os.flush();
+            byte[] data = new byte[2048];
+            int len = is.read(data);
+            if (len <= 0) {
+                throw new IOException("no data received");
+            }
+            System.out.printf("client received %d bytes: %s%n", len, new String(data, 0, len));
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+
+        startClient("localhost", 8443);
+    }
+}
@@ -0,0 +1,46 @@
+package com.baeldung.httpsclientauthentication;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+import javax.net.ServerSocketFactory;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLServerSocketFactory;
+
+public class SSLSocketEchoServer {
+
+    static void startServer(int port) throws IOException {
+
+        ServerSocketFactory factory = SSLServerSocketFactory.getDefault();
+
+        try (SSLServerSocket listener = (SSLServerSocket) factory.createServerSocket(port)) {
+            listener.setNeedClientAuth(true);
+            listener.setEnabledCipherSuites(new String[] { "TLS_AES_128_GCM_SHA256" });
+            listener.setEnabledProtocols(new String[] { "TLSv1.3" });
+            System.out.println("listening for messages...");
+            try (Socket socket = listener.accept()) {
+                InputStream is = new BufferedInputStream(socket.getInputStream());
+                OutputStream os = new BufferedOutputStream(socket.getOutputStream());
+                byte[] data = new byte[2048];
+                int len = is.read(data);
+                if (len <= 0) {
+                    throw new IOException("no data received");
+                }
+                String message = new String(data, 0, len);
+                System.out.printf("server received %d bytes: %s%n", len, message);
+                String response = message + " processed by server";
+                os.write(response.getBytes(), 0, response.getBytes().length);
+                os.flush();
+            }
+            System.out.println("message processed, exiting");
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        startServer(8443);
+    }
+}
@@ -0,0 +1,13 @@
+package com.baeldung.optional;
+
+public class Modem {
+    private Double price;
+
+    public Modem(Double price) {
+        this.price = price;
+    }
+
+    public Double getPrice() {
+        return price;
+    }
+}
@@ -0,0 +1,74 @@
+package com.baeldung.optional;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class Person {
+    private String name;
+    private int age;
+    private String password;
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public Optional<String> getName() {
+        return Optional.ofNullable(name);
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Optional<Integer> getAge() {
+        return Optional.of(age);
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public Optional<String> getPassword() {
+        return Optional.ofNullable(password);
+    }
+
+    public static List<Person> search(List<Person> people, String name, Optional<Integer> age) {
+        // Null checks for people and name
+        return people.stream()
+                .filter(p -> p.getName().equals(name))
+                .filter(p -> p.getAge().get() >= age.orElse(0))
+                .collect(Collectors.toList());
+    }
+
+    public static List<Person> search(List<Person> people, String name, Integer age) {
+        // Null checks for people and name
+        final Integer ageFilter = age != null ? age : 0;
+
+        return people.stream()
+                .filter(p -> p.getName().equals(name))
+                .filter(p -> p.getAge().get() >= ageFilter)
+                .collect(Collectors.toList());
+    }
+
+    public static List<Person> search(List<Person> people, String name) {
+        return doSearch(people, name, 0);
+    }
+
+    public static List<Person> search(List<Person> people, String name, int age) {
+        return doSearch(people, name, age);
+    }
+
+    private static List<Person> doSearch(List<Person> people, String name, int age) {
+        // Null checks for people and name
+        return people.stream()
+                .filter(p -> p.getName().equals(name))
+                .filter(p -> p.getAge().get().intValue() >= age)
+                .collect(Collectors.toList());
+    }
+}
@@ -0,0 +1,23 @@
+package com.baeldung.reflection;
+
+public abstract class Animal implements Eating {
+
+    public static final String CATEGORY = "domestic";
+
+    private String name;
+
+    public Animal(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    protected abstract String getSound();
+
+}
@@ -0,0 +1,36 @@
+package com.baeldung.reflection;
+
+public class Bird extends Animal {
+    private boolean walks;
+
+    public Bird() {
+        super("bird");
+    }
+
+    public Bird(String name, boolean walks) {
+        super(name);
+        setWalks(walks);
+    }
+
+    public Bird(String name) {
+        super(name);
+    }
+
+    @Override
+    public String eats() {
+        return "grains";
+    }
+
+    @Override
+    protected String getSound() {
+        return "chaps";
+    }
+
+    public boolean walks() {
+        return walks;
+    }
+
+    public void setWalks(boolean walks) {
+        this.walks = walks;
+    }
+}
@@ -0,0 +1,23 @@
+package com.baeldung.reflection;
+
+import java.lang.annotation.Annotation;
+
+public class DynamicGreeter implements Greeter {
+    
+    private String greet;
+
+    public DynamicGreeter(String greet) {
+        this.greet = greet;
+    }
+
+    @Override
+    public Class<? extends Annotation> annotationType() {
+        return DynamicGreeter.class;
+    }
+
+    @Override
+    public String greet() {
+        return greet;
+    }
+
+}
@@ -0,0 +1,5 @@
+package com.baeldung.reflection;
+
+public interface Eating {
+    String eats();
+}
@@ -0,0 +1,24 @@
+package com.baeldung.reflection;
+
+public class Goat extends Animal implements Locomotion {
+
+    public Goat(String name) {
+        super(name);
+    }
+
+    @Override
+    protected String getSound() {
+        return "bleat";
+    }
+
+    @Override
+    public String getLocomotion() {
+        return "walks";
+    }
+
+    @Override
+    public String eats() {
+        return "grass";
+    }
+
+}
@@ -0,0 +1,10 @@
+package com.baeldung.reflection;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Greeter {
+
+    public String greet() default "";
+}
@@ -0,0 +1,58 @@
+package com.baeldung.reflection;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+public class GreetingAnnotation {
+   
+    private static final String ANNOTATION_METHOD = "annotationData";
+    private static final String ANNOTATION_FIELDS = "declaredAnnotations";
+    private static final String ANNOTATIONS = "annotations";
+
+    public static void main(String ...args) {
+        Greeter greetings = Greetings.class.getAnnotation(Greeter.class);
+        System.err.println("Hello there, " + greetings.greet() + " !!");
+
+        Greeter targetValue = new DynamicGreeter("Good evening");
+        //alterAnnotationValueJDK8(Greetings.class, Greeter.class, targetValue);
+        alterAnnotationValueJDK7(Greetings.class, Greeter.class, targetValue);
+        
+        greetings = Greetings.class.getAnnotation(Greeter.class);
+        System.err.println("Hello there, " + greetings.greet() + " !!");
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void alterAnnotationValueJDK8(Class<?> targetClass, Class<? extends Annotation> targetAnnotation, Annotation targetValue) {
+        try {
+            Method method = Class.class.getDeclaredMethod(ANNOTATION_METHOD, null);
+            method.setAccessible(true);
+
+            Object annotationData = method.invoke(targetClass);
+            
+            Field annotations = annotationData.getClass().getDeclaredField(ANNOTATIONS);
+            annotations.setAccessible(true);
+
+            Map<Class<? extends Annotation>, Annotation> map = (Map<Class<? extends Annotation>, Annotation>) annotations.get(annotationData);
+            map.put(targetAnnotation, targetValue);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void alterAnnotationValueJDK7(Class<?> targetClass, Class<? extends Annotation> targetAnnotation, Annotation targetValue) {
+        try {            
+            Field annotations = Class.class.getDeclaredField(ANNOTATIONS);
+            annotations.setAccessible(true);
+
+            Map<Class<? extends Annotation>, Annotation> map = (Map<Class<? extends Annotation>, Annotation>) annotations.get(targetClass);
+            System.out.println(map);
+            map.put(targetAnnotation, targetValue);
+            System.out.println(map);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
@@ -0,0 +1,6 @@
+package com.baeldung.reflection;
+
+@Greeter(greet="Good morning")
+public class Greetings {
+
+}
@@ -0,0 +1,5 @@
+package com.baeldung.reflection;
+
+public interface Locomotion {
+    String getLocomotion();
+}
@@ -0,0 +1,21 @@
+package com.baeldung.reflection;
+
+public class Operations {
+
+    public double publicSum(int a, double b) {
+        return a + b;
+    }
+
+    public static double publicStaticMultiply(float a, long b) {
+        return a * b;
+    }
+
+    private boolean privateAnd(boolean a, boolean b) {
+        return a && b;
+    }
+
+    protected int protectedMax(int a, int b) {
+        return a > b ? a : b;
+    }
+
+}
@@ -0,0 +1,6 @@
+package com.baeldung.reflection;
+
+public class Person {
+    private String name;
+    private int age;
+}
@@ -0,0 +1,135 @@
+
+package com.baeldung.soap.ws.client.generated;
+
+import jakarta.xml.bind.annotation.XmlAccessType;
+import jakarta.xml.bind.annotation.XmlAccessorType;
+import jakarta.xml.bind.annotation.XmlSchemaType;
+import jakarta.xml.bind.annotation.XmlType;
+
+
+/**
+ * <p>Java class for country complex type.
+ * 
+ * <p>The following schema fragment specifies the expected content contained within this class.
+ * 
+ * <pre>
+ * &lt;complexType name="country"&gt;
+ *   &lt;complexContent&gt;
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
+ *       &lt;sequence&gt;
+ *         &lt;element name="capital" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/&gt;
+ *         &lt;element name="currency" type="{http://server.ws.soap.baeldung.com/}currency" minOccurs="0"/&gt;
+ *         &lt;element name="name" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/&gt;
+ *         &lt;element name="population" type="{http://www.w3.org/2001/XMLSchema}int"/&gt;
+ *       &lt;/sequence&gt;
+ *     &lt;/restriction&gt;
+ *   &lt;/complexContent&gt;
+ * &lt;/complexType&gt;
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "country", propOrder = {
+    "capital",
+    "currency",
+    "name",
+    "population"
+})
+public class Country {
+
+    protected String capital;
+    @XmlSchemaType(name = "string")
+    protected Currency currency;
+    protected String name;
+    protected int population;
+
+    /**
+     * Gets the value of the capital property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getCapital() {
+        return capital;
+    }
+
+    /**
+     * Sets the value of the capital property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setCapital(String value) {
+        this.capital = value;
+    }
+
+    /**
+     * Gets the value of the currency property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link Currency }
+     *     
+     */
+    public Currency getCurrency() {
+        return currency;
+    }
+
+    /**
+     * Sets the value of the currency property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Currency }
+     *     
+     */
+    public void setCurrency(Currency value) {
+        this.currency = value;
+    }
+
+    /**
+     * Gets the value of the name property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Sets the value of the name property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setName(String value) {
+        this.name = value;
+    }
+
+    /**
+     * Gets the value of the population property.
+     * 
+     */
+    public int getPopulation() {
+        return population;
+    }
+
+    /**
+     * Sets the value of the population property.
+     * 
+     */
+    public void setPopulation(int value) {
+        this.population = value;
+    }
+
+}
@@ -0,0 +1,40 @@
+
+package com.baeldung.soap.ws.client.generated;
+
+import jakarta.jws.WebMethod;
+import jakarta.jws.WebParam;
+import jakarta.jws.WebResult;
+import jakarta.jws.WebService;
+import jakarta.jws.soap.SOAPBinding;
+import jakarta.xml.bind.annotation.XmlSeeAlso;
+import jakarta.xml.ws.Action;
+
+
+/**
+ * This class was generated by the JAX-WS RI.
+ * JAX-WS RI 3.0.2
+ * Generated source version: 3.0
+ * 
+ */
+@WebService(name = "CountryService", targetNamespace = "http://server.ws.soap.baeldung.com/")
+@SOAPBinding(style = SOAPBinding.Style.RPC)
+@XmlSeeAlso({
+    ObjectFactory.class
+})
+public interface CountryService {
+
+
+    /**
+     * 
+     * @param arg0
+     * @return
+     *     returns com.baeldung.soap.ws.client.generated.Country
+     */
+    @WebMethod
+    @WebResult(partName = "return")
+    @Action(input = "http://server.ws.soap.baeldung.com/CountryService/findByNameRequest", output = "http://server.ws.soap.baeldung.com/CountryService/findByNameResponse")
+    public Country findByName(
+        @WebParam(name = "arg0", partName = "arg0")
+        String arg0);
+
+}
@@ -0,0 +1,94 @@
+
+package com.baeldung.soap.ws.client.generated;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import javax.xml.namespace.QName;
+import jakarta.xml.ws.Service;
+import jakarta.xml.ws.WebEndpoint;
+import jakarta.xml.ws.WebServiceClient;
+import jakarta.xml.ws.WebServiceException;
+import jakarta.xml.ws.WebServiceFeature;
+
+
+/**
+ * This class was generated by the JAX-WS RI.
+ * JAX-WS RI 3.0.2
+ * Generated source version: 3.0
+ * 
+ */
+@WebServiceClient(name = "CountryServiceImplService", targetNamespace = "http://server.ws.soap.baeldung.com/", wsdlLocation = "http://localhost:8888/ws/country?wsdl")
+public class CountryServiceImplService
+    extends Service
+{
+
+    private final static URL COUNTRYSERVICEIMPLSERVICE_WSDL_LOCATION;
+    private final static WebServiceException COUNTRYSERVICEIMPLSERVICE_EXCEPTION;
+    private final static QName COUNTRYSERVICEIMPLSERVICE_QNAME = new QName("http://server.ws.soap.baeldung.com/", "CountryServiceImplService");
+
+    static {
+        URL url = null;
+        WebServiceException e = null;
+        try {
+            url = new URL("http://localhost:8888/ws/country?wsdl");
+        } catch (MalformedURLException ex) {
+            e = new WebServiceException(ex);
+        }
+        COUNTRYSERVICEIMPLSERVICE_WSDL_LOCATION = url;
+        COUNTRYSERVICEIMPLSERVICE_EXCEPTION = e;
+    }
+
+    public CountryServiceImplService() {
+        super(__getWsdlLocation(), COUNTRYSERVICEIMPLSERVICE_QNAME);
+    }
+
+    public CountryServiceImplService(WebServiceFeature... features) {
+        super(__getWsdlLocation(), COUNTRYSERVICEIMPLSERVICE_QNAME, features);
+    }
+
+    public CountryServiceImplService(URL wsdlLocation) {
+        super(wsdlLocation, COUNTRYSERVICEIMPLSERVICE_QNAME);
+    }
+
+    public CountryServiceImplService(URL wsdlLocation, WebServiceFeature... features) {
+        super(wsdlLocation, COUNTRYSERVICEIMPLSERVICE_QNAME, features);
+    }
+
+    public CountryServiceImplService(URL wsdlLocation, QName serviceName) {
+        super(wsdlLocation, serviceName);
+    }
+
+    public CountryServiceImplService(URL wsdlLocation, QName serviceName, WebServiceFeature... features) {
+        super(wsdlLocation, serviceName, features);
+    }
+
+    /**
+     * 
+     * @return
+     *     returns CountryService
+     */
+    @WebEndpoint(name = "CountryServiceImplPort")
+    public CountryService getCountryServiceImplPort() {
+        return super.getPort(new QName("http://server.ws.soap.baeldung.com/", "CountryServiceImplPort"), CountryService.class);
+    }
+
+    /**
+     * 
+     * @param features
+     *     A list of {@link jakarta.xml.ws.WebServiceFeature} to configure on the proxy.  Supported features not in the <code>features</code> parameter will have their default values.
+     * @return
+     *     returns CountryService
+     */
+    @WebEndpoint(name = "CountryServiceImplPort")
+    public CountryService getCountryServiceImplPort(WebServiceFeature... features) {
+        return super.getPort(new QName("http://server.ws.soap.baeldung.com/", "CountryServiceImplPort"), CountryService.class, features);
+    }
+
+    private static URL __getWsdlLocation() {
+        if (COUNTRYSERVICEIMPLSERVICE_EXCEPTION!= null) {
+            throw COUNTRYSERVICEIMPLSERVICE_EXCEPTION;
+        }
+        return COUNTRYSERVICEIMPLSERVICE_WSDL_LOCATION;
+    }
+
+}
@@ -0,0 +1,39 @@
+
+package com.baeldung.soap.ws.client.generated;
+
+import jakarta.xml.bind.annotation.XmlEnum;
+import jakarta.xml.bind.annotation.XmlType;
+
+
+/**
+ * <p>Java class for currency.
+ * 
+ * <p>The following schema fragment specifies the expected content contained within this class.
+ * <pre>
+ * &lt;simpleType name="currency"&gt;
+ *   &lt;restriction base="{http://www.w3.org/2001/XMLSchema}string"&gt;
+ *     &lt;enumeration value="EUR"/&gt;
+ *     &lt;enumeration value="INR"/&gt;
+ *     &lt;enumeration value="USD"/&gt;
+ *   &lt;/restriction&gt;
+ * &lt;/simpleType&gt;
+ * </pre>
+ * 
+ */
+@XmlType(name = "currency")
+@XmlEnum
+public enum Currency {
+
+    EUR,
+    INR,
+    USD;
+
+    public String value() {
+        return name();
+    }
+
+    public static Currency fromValue(String v) {
+        return valueOf(v);
+    }
+
+}
@@ -0,0 +1,40 @@
+
+package com.baeldung.soap.ws.client.generated;
+
+import jakarta.xml.bind.annotation.XmlRegistry;
+
+
+/**
+ * This object contains factory methods for each 
+ * Java content interface and Java element interface 
+ * generated in the com.baeldung.soap.ws.client.generated package. 
+ * <p>An ObjectFactory allows you to programatically 
+ * construct new instances of the Java representation 
+ * for XML content. The Java representation of XML 
+ * content can consist of schema derived interfaces 
+ * and classes representing the binding of schema 
+ * type definitions, element declarations and model 
+ * groups.  Factory methods for each of these are 
+ * provided in this class.
+ * 
+ */
+@XmlRegistry
+public class ObjectFactory {
+
+
+    /**
+     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: com.baeldung.soap.ws.client.generated
+     * 
+     */
+    public ObjectFactory() {
+    }
+
+    /**
+     * Create an instance of {@link Country }
+     * 
+     */
+    public Country createCountry() {
+        return new Country();
+    }
+
+}
@@ -0,0 +1,2 @@
+@jakarta.xml.bind.annotation.XmlSchema(namespace = "http://server.ws.soap.baeldung.com/")
+package com.baeldung.soap.ws.client.generated;
@@ -0,0 +1,41 @@
+package com.baeldung.soap.ws.server;
+
+public class Country {
+    protected String name;
+    protected int population;
+    protected String capital;
+    protected Currency currency;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getPopulation() {
+        return population;
+    }
+
+    public void setPopulation(int population) {
+        this.population = population;
+    }
+
+    public String getCapital() {
+        return capital;
+    }
+
+    public void setCapital(String capital) {
+        this.capital = capital;
+    }
+
+    public Currency getCurrency() {
+        return currency;
+    }
+
+    public void setCurrency(Currency currency) {
+        this.currency = currency;
+    }
+
+}
@@ -0,0 +1,43 @@
+package com.baeldung.soap.ws.server;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class CountryRepository {
+
+    private static final Map<String, Country> countries = new HashMap<>();
+
+    {
+        initData();
+    }
+
+    private final static void initData() {
+        Country usa = new Country();
+        usa.setName("USA");
+        usa.setCapital("Washington D.C.");
+        usa.setCurrency(Currency.USD);
+        usa.setPopulation(323947000);
+
+        countries.put(usa.getName(), usa);
+
+        Country india = new Country();
+        india.setName("India");
+        india.setCapital("New Delhi");
+        india.setCurrency(Currency.INR);
+        india.setPopulation(1295210000);
+
+        countries.put(india.getName(), india);
+
+        Country france = new Country();
+        france.setName("France");
+        france.setCapital("Paris");
+        france.setCurrency(Currency.EUR);
+        france.setPopulation(66710000);
+
+        countries.put(france.getName(), france);
+    }
+
+    public Country findCountry(String name) {
+        return countries.get(name);
+    }
+}
@@ -0,0 +1,15 @@
+package com.baeldung.soap.ws.server;
+
+import jakarta.jws.WebMethod;
+import jakarta.jws.WebService;
+import jakarta.jws.soap.SOAPBinding;
+import jakarta.jws.soap.SOAPBinding.Style;
+
+@WebService
+@SOAPBinding(style=Style.RPC)
+public interface CountryService {
+    
+    @WebMethod
+    Country findByName(String name);
+
+}
@@ -0,0 +1,15 @@
+package com.baeldung.soap.ws.server;
+
+import jakarta.jws.WebService;
+
+@WebService(endpointInterface = "com.baeldung.soap.ws.server.CountryService")
+public class CountryServiceImpl implements CountryService {
+
+    private CountryRepository countryRepository = new CountryRepository();
+
+    @Override
+    public Country findByName(String name) {
+        return countryRepository.findCountry(name);
+    }
+
+}
@@ -0,0 +1,19 @@
+package com.baeldung.soap.ws.server;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jakarta.xml.ws.Endpoint;
+
+
+public class CountryServicePublisher {
+    
+    private static final Logger logger = LoggerFactory.getLogger(CountryServicePublisher.class);
+    
+    public static void main(String[] args) {
+        Endpoint endpoint = Endpoint.create(new CountryServiceImpl());
+        endpoint.publish("http://localhost:8888/ws/country");
+        
+        logger.info("Country web service ready to consume requests!");
+    }
+}
@@ -0,0 +1,15 @@
+package com.baeldung.soap.ws.server;
+
+public enum Currency {
+
+    EUR, INR, USD;
+
+    public String value() {
+        return name();
+    }
+
+    public static Currency fromValue(String v) {
+        return valueOf(v);
+    }
+
+}
@@ -0,0 +1,54 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.mockserver.integration.ClientAndServer;
+import org.mockserver.model.HttpStatusCode;
+import org.mockserver.socket.PortFactory;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockserver.integration.ClientAndServer.startClientAndServer;
+
+class HttpClientIntegrationTest {
+
+    private static ClientAndServer mockServer;
+    private static int port;
+
+    @BeforeAll
+    static void startServer() {
+        port = PortFactory.findFreePort();
+        mockServer = startClientAndServer(port);
+        mockServer.when(new org.mockserver.model.HttpRequest().withMethod("GET"))
+          .respond(new org.mockserver.model.HttpResponse()
+            .withStatusCode(HttpStatusCode.OK_200.code())
+            .withBody("Hello from the server!"));
+    }
+
+    @AfterAll
+    static void stopServer() {
+        mockServer.stop();
+    }
+
+    @Test
+    void givenSampleHttpRequest_whenRequestIsSent_thenServerResponseIsReceived() throws IOException, InterruptedException {
+        HttpClient httpClient = HttpClient.newBuilder()
+          .version(HttpClient.Version.HTTP_2)
+          .connectTimeout(Duration.ofSeconds(20))
+          .build();
+        HttpRequest httpRequest = HttpRequest.newBuilder()
+          .GET()
+          .uri(URI.create("http://localhost:" + port))
+          .build();
+        HttpResponse<String> httpResponse = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString());
+        assertThat(httpResponse.body()).isEqualTo("Hello from the server!");
+    }
+
+}
@@ -0,0 +1,61 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JavaElevenFeaturesUnitTest {
+
+    @Test
+    void givenMultilineString_whenExtractingNonBlankStrippedLines_thenLinesAreReturned() {
+        String multilineString = "Baeldung helps \n \n developers \n explore Java.";
+        List<String> lines = multilineString.lines()
+          .filter(line -> !line.isBlank())
+          .map(String::strip)
+          .collect(Collectors.toList());
+        assertThat(lines).containsExactly("Baeldung helps", "developers", "explore Java.");
+    }
+
+    @Test
+    void givenTemporaryFile_whenReadingStringContent_thenContentIsReturned(@TempDir Path tempDir) throws IOException {
+        Path filePath = Files.writeString(Files.createTempFile(tempDir, "demo", ".txt"), "Sample text");
+        String fileContent = Files.readString(filePath);
+        assertThat(fileContent).isEqualTo("Sample text");
+    }
+
+    @Test
+    void givenSampleList_whenConvertingToArray_thenItemsRemainUnchanged() {
+        List<String> sampleList = Arrays.asList("Java", "Kotlin");
+        String[] sampleArray = sampleList.toArray(String[]::new);
+        assertThat(sampleArray).containsExactly("Java", "Kotlin");
+    }
+
+    @Test
+    void givenSampleList_whenConvertingToUppercaseString_thenUppercaseIsReturned() {
+        List<String> sampleList = Arrays.asList("Java", "Kotlin");
+        String resultString = sampleList.stream()
+          .map((@Nonnull var x) -> x.toUpperCase())
+          .collect(Collectors.joining(", "));
+        assertThat(resultString).isEqualTo("JAVA, KOTLIN");
+    }
+
+    @Test
+    void givenSampleList_whenExtractingNonBlankValues_thenOnlyNonBlanksAreReturned() {
+        List<String> sampleList = Arrays.asList("Java", "\n \n", "Kotlin", " ");
+        List<String> withoutBlanks = sampleList.stream()
+          .filter(Predicate.not(String::isBlank))
+          .collect(Collectors.toList());
+        assertThat(withoutBlanks).containsExactly("Java", "Kotlin");
+    }
+
+}
@@ -0,0 +1,37 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class NestedClassesUnitTest {
+
+    @Test
+    public void giveNestedClass_whenCallingMainClassPrivateMethod_thenNoExceptionIsThrown() {
+        MainClass.NestedClass nestedInstance = new MainClass.NestedClass();
+        assertThat(nestedInstance.nestedPublicMethod()).isTrue();
+    }
+
+    @Test
+    public void giveNestedClass_whenCheckingNestmate_thenNestedClassIsReturned() {
+        assertThat(MainClass.class.isNestmateOf(MainClass.NestedClass.class)).isTrue();
+    }
+
+    @Test
+    public void giveNestedClass_whenCheckingNestHost_thenMainClassIsReturned() {
+        assertThat(MainClass.NestedClass.class.getNestHost()).isEqualTo(MainClass.class);
+    }
+
+    @Test
+    public void giveNestedClass_whenCheckingNestMembers_thenNestMembersAreReturned() {
+        Set<String> nestedMembers = Arrays.stream(MainClass.NestedClass.class.getNestMembers())
+          .map(Class::getName)
+          .collect(Collectors.toSet());
+        assertThat(nestedMembers).contains(MainClass.class.getName(), MainClass.NestedClass.class.getName());
+    }
+
+}
@@ -0,0 +1,87 @@
+package com.baeldung.httpclient.ssl;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.X509Certificate;
+import java.util.Properties;
+
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLEngine;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509ExtendedTrustManager;
+
+public class HttpClientSSLBypassUnitTest {
+
+    @Test
+    public void givenDisableUsingJVMProperty_whenByPassCertificationVerification_thenSuccessHttpResponse() throws IOException, InterruptedException {
+        final Properties props = System.getProperties();
+        props.setProperty("jdk.internal.httpclient.disableHostnameVerification", Boolean.TRUE.toString());
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .build();
+
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(URI.create("https://wrong.host.badssl.com/"))
+            .build();
+
+        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+        props.setProperty("jdk.internal.httpclient.disableHostnameVerification", Boolean.FALSE.toString());
+
+        Assertions.assertEquals(200, response.statusCode());
+    }
+
+    @Test
+    public void givenMockTrustManager_whenByPassCertificateVerification_thenSuccessHttpResponse() throws IOException, InterruptedException, NoSuchAlgorithmException, KeyManagementException, URISyntaxException {
+        SSLContext sslContext = SSLContext.getInstance("SSL"); // OR TLS
+        sslContext.init(null, new TrustManager[]{ MOCK_TRUST_MANAGER }, new SecureRandom());
+        HttpClient httpClient = HttpClient.newBuilder().sslContext(sslContext).build();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://wrong.host.badssl.com/"))
+            .build();
+        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+        Assertions.assertEquals(200, response.statusCode());
+    }
+
+
+    private static final TrustManager MOCK_TRUST_MANAGER = new X509ExtendedTrustManager() {
+        @Override
+        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+            return new java.security.cert.X509Certificate[0];
+        }
+
+        @Override
+        public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) {
+        }
+
+        @Override
+        public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) {
+        }
+
+        @Override
+        public void checkServerTrusted(X509Certificate[] chain, String authType, SSLEngine engine) {
+        }
+
+        @Override
+        public void checkServerTrusted(X509Certificate[] chain, String authType, Socket socket) {
+        }
+
+        @Override
+        public void checkClientTrusted(X509Certificate[] chain, String authType, SSLEngine engine) {
+        }
+
+        @Override
+        public void checkClientTrusted(X509Certificate[] chain, String authType, Socket socket) {
+        }
+    };
+}
@@ -0,0 +1,41 @@
+package com.baeldung.httpclient.ssl;
+
+import org.junit.Test;
+
+import javax.net.ssl.SSLHandshakeException;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+
+import static org.junit.Assert.assertEquals;
+
+public class HttpClientSSLUnitTest {
+
+    @Test
+    public void whenValidHttpsRequest_thenCorrect() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        HttpRequest request = HttpRequest.newBuilder()
+          .uri(new URI("https://www.google.com/"))
+          .build();
+
+        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertEquals(200, response.statusCode());
+    }
+
+    @Test(expected = SSLHandshakeException.class)
+    public void whenInvalidHttpsRequest_thenInCorrect() throws IOException, InterruptedException {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        HttpRequest request = HttpRequest.newBuilder()
+          .uri(URI.create("https://expired.badssl.com/"))
+          .build();
+
+        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertEquals(200, response.statusCode());
+    }
+
+}
@@ -0,0 +1,112 @@
+package com.baeldung.optional;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Optional;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class OptionalChainingUnitTest {
+
+    private boolean getEmptyEvaluated;
+    private boolean getHelloEvaluated;
+    private boolean getByeEvaluated;
+
+    @Before
+    public void setUp() {
+        getEmptyEvaluated = false;
+        getHelloEvaluated = false;
+        getByeEvaluated = false;
+    }
+
+    @Test
+    public void givenThreeOptionals_whenChaining_thenFirstNonEmptyIsReturned() {
+        Optional<String> found = Stream.of(getEmpty(), getHello(), getBye())
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+        assertEquals(getHello(), found);
+    }
+
+    @Test
+    public void givenTwoEmptyOptionals_whenChaining_thenEmptyOptionalIsReturned() {
+        Optional<String> found = Stream.of(getEmpty(), getEmpty())
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+        assertFalse(found.isPresent());
+    }
+
+    @Test
+    public void givenTwoEmptyOptionals_whenChaining_thenDefaultIsReturned() {
+        String found = Stream.<Supplier<Optional<String>>>of(
+                () -> createOptional("empty"),
+                () -> createOptional("empty")
+        )
+                .map(Supplier::get)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst()
+                .orElseGet(() -> "default");
+
+        assertEquals("default", found);
+    }
+
+    @Test
+    public void givenThreeOptionals_whenChaining_thenFirstNonEmptyIsReturnedAndRestNotEvaluated() {
+        Optional<String> found = Stream.<Supplier<Optional<String>>>of(this::getEmpty, this::getHello, this::getBye)
+                .map(Supplier::get)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+        assertTrue(this.getEmptyEvaluated);
+        assertTrue(this.getHelloEvaluated);
+        assertFalse(this.getByeEvaluated);
+        assertEquals(getHello(), found);
+    }
+
+    @Test
+    public void givenTwoOptionalsReturnedByOneArgMethod_whenChaining_thenFirstNonEmptyIsReturned() {
+        Optional<String> found = Stream.<Supplier<Optional<String>>>of(
+                () -> createOptional("empty"),
+                () -> createOptional("hello")
+        )
+                .map(Supplier::get)
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .findFirst();
+
+        assertEquals(createOptional("hello"), found);
+    }
+
+    private Optional<String> getEmpty() {
+        this.getEmptyEvaluated = true;
+        return Optional.empty();
+    }
+
+    private Optional<String> getHello() {
+        this.getHelloEvaluated = true;
+        return Optional.of("hello");
+    }
+
+    private Optional<String> getBye() {
+        this.getByeEvaluated = true;
+        return Optional.of("bye");
+    }
+
+    private Optional<String> createOptional(String input) {
+        if (input == null || "".equals(input) || "empty".equals(input)) {
+            return Optional.empty();
+        }
+
+        return Optional.of(input);
+    }
+}
@@ -0,0 +1,288 @@
+package com.baeldung.optional;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Optional;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class OptionalUnitTest {
+
+    private static final Logger LOG = LoggerFactory.getLogger(OptionalUnitTest.class);
+
+    // creating Optional
+    @Test
+    public void whenCreatesEmptyOptional_thenCorrect() {
+        Optional<String> empty = Optional.empty();
+        assertFalse(empty.isPresent());
+    }
+
+    @Test
+    public void givenNonNull_whenCreatesNonNullable_thenCorrect() {
+        String name = "baeldung";
+        Optional<String> opt = Optional.of(name);
+        assertTrue(opt.isPresent());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void givenNull_whenThrowsErrorOnCreate_thenCorrect() {
+        String name = null;
+        Optional.of(name);
+    }
+
+    @Test
+    public void givenNonNull_whenCreatesOptional_thenCorrect() {
+        String name = "baeldung";
+        Optional<String> opt = Optional.of(name);
+        assertTrue(opt.isPresent());
+    }
+
+    @Test
+    public void givenNonNull_whenCreatesNullable_thenCorrect() {
+        String name = "baeldung";
+        Optional<String> opt = Optional.ofNullable(name);
+        assertTrue(opt.isPresent());
+    }
+
+    @Test
+    public void givenNull_whenCreatesNullable_thenCorrect() {
+        String name = null;
+        Optional<String> opt = Optional.ofNullable(name);
+        assertFalse(opt.isPresent());
+    }
+    // Checking Value With isPresent()
+
+    @Test
+    public void givenOptional_whenIsPresentWorks_thenCorrect() {
+        Optional<String> opt = Optional.of("Baeldung");
+        assertTrue(opt.isPresent());
+
+        opt = Optional.ofNullable(null);
+        assertFalse(opt.isPresent());
+    }
+
+    // Condition Action With ifPresent()
+    @Test
+    public void givenOptional_whenIfPresentWorks_thenCorrect() {
+        Optional<String> opt = Optional.of("baeldung");
+        opt.ifPresent(name -> LOG.debug("{}", name.length()));
+    }
+
+    // returning Value With get()
+    @Test
+    public void givenOptional_whenGetsValue_thenCorrect() {
+        Optional<String> opt = Optional.of("baeldung");
+        String name = opt.get();
+        assertEquals("baeldung", name);
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void givenOptionalWithNull_whenGetThrowsException_thenCorrect() {
+        Optional<String> opt = Optional.ofNullable(null);
+        String name = opt.get();
+    }
+    
+    @Test
+    public void givenAnEmptyOptional_thenIsEmptyBehavesAsExpected() {
+        Optional<String> opt = Optional.of("Baeldung");
+        assertTrue(opt.isPresent());
+     
+        opt = Optional.ofNullable(null);
+        assertFalse(opt.isPresent());
+    }
+
+    // Conditional Return With filter()
+    @Test
+    public void whenOptionalFilterWorks_thenCorrect() {
+        Integer year = 2016;
+        Optional<Integer> yearOptional = Optional.of(year);
+        boolean is2016 = yearOptional.filter(y -> y == 2016)
+            .isPresent();
+        assertTrue(is2016);
+        boolean is2017 = yearOptional.filter(y -> y == 2017)
+            .isPresent();
+        assertFalse(is2017);
+    }
+
+    @Test
+    public void whenFiltersWithoutOptional_thenCorrect() {
+        assertTrue(priceIsInRange1(new Modem(10.0)));
+        assertFalse(priceIsInRange1(new Modem(9.9)));
+        assertFalse(priceIsInRange1(new Modem(null)));
+        assertFalse(priceIsInRange1(new Modem(15.5)));
+        assertFalse(priceIsInRange1(null));
+
+    }
+
+    @Test
+    public void whenFiltersWithOptional_thenCorrect() {
+        assertTrue(priceIsInRange2(new Modem(10.0)));
+        assertFalse(priceIsInRange2(new Modem(9.9)));
+        assertFalse(priceIsInRange2(new Modem(null)));
+        assertFalse(priceIsInRange2(new Modem(15.5)));
+        assertFalse(priceIsInRange1(null));
+    }
+
+    public boolean priceIsInRange1(Modem modem) {
+        boolean isInRange = false;
+        if (modem != null && modem.getPrice() != null && (modem.getPrice() >= 10 && modem.getPrice() <= 15)) {
+            isInRange = true;
+        }
+        return isInRange;
+    }
+
+    public boolean priceIsInRange2(Modem modem2) {
+        return Optional.ofNullable(modem2)
+            .map(Modem::getPrice)
+            .filter(p -> p >= 10)
+            .filter(p -> p <= 15)
+            .isPresent();
+    }
+
+    // Transforming Value With map()
+    @Test
+    public void givenOptional_whenMapWorks_thenCorrect() {
+        List<String> companyNames = Arrays.asList("paypal", "oracle", "", "microsoft", "", "apple");
+        Optional<List<String>> listOptional = Optional.of(companyNames);
+
+        int size = listOptional.map(List::size)
+            .orElse(0);
+        assertEquals(6, size);
+    }
+
+    @Test
+    public void givenOptional_whenMapWorks_thenCorrect2() {
+        String name = "baeldung";
+        Optional<String> nameOptional = Optional.of(name);
+
+        int len = nameOptional.map(String::length)
+            .orElse(0);
+        assertEquals(8, len);
+    }
+
+    @Test
+    public void givenOptional_whenMapWorksWithFilter_thenCorrect() {
+        String password = " password ";
+        Optional<String> passOpt = Optional.of(password);
+        boolean correctPassword = passOpt.filter(pass -> pass.equals("password"))
+            .isPresent();
+        assertFalse(correctPassword);
+
+        correctPassword = passOpt.map(String::trim)
+            .filter(pass -> pass.equals("password"))
+            .isPresent();
+        assertTrue(correctPassword);
+    }
+
+    // Transforming Value With flatMap()
+    @Test
+    public void givenOptional_whenFlatMapWorks_thenCorrect2() {
+        Person person = new Person("john", 26);
+        Optional<Person> personOptional = Optional.of(person);
+
+        Optional<Optional<String>> nameOptionalWrapper = personOptional.map(Person::getName);
+        Optional<String> nameOptional = nameOptionalWrapper.orElseThrow(IllegalArgumentException::new);
+        String name1 = nameOptional.orElseThrow(IllegalArgumentException::new);
+        assertEquals("john", name1);
+
+        String name = personOptional.flatMap(Person::getName)
+            .orElseThrow(IllegalArgumentException::new);
+        assertEquals("john", name);
+    }
+
+    @Test
+    public void givenOptional_whenFlatMapWorksWithFilter_thenCorrect() {
+        Person person = new Person("john", 26);
+        person.setPassword("password");
+        Optional<Person> personOptional = Optional.of(person);
+
+        String password = personOptional.flatMap(Person::getPassword)
+            .filter(cleanPass -> cleanPass.equals("password"))
+            .orElseThrow(IllegalArgumentException::new);
+        assertEquals("password", password);
+    }
+
+    // Default Value With orElse
+    @Test
+    public void whenOrElseWorks_thenCorrect() {
+        String nullName = null;
+        String name = Optional.ofNullable(nullName)
+            .orElse("john");
+        assertEquals("john", name);
+    }
+
+    // Default Value With orElseGet
+    @Test
+    public void whenOrElseGetWorks_thenCorrect() {
+        String nullName = null;
+        String name = Optional.ofNullable(nullName)
+            .orElseGet(() -> "john");
+        assertEquals("john", name);
+
+    }
+
+    @Test
+    public void whenOrElseGetAndOrElseOverlap_thenCorrect() {
+        String text = null;
+        LOG.debug("Using orElseGet:");
+        String defaultText = Optional.ofNullable(text)
+            .orElseGet(this::getMyDefault);
+        assertEquals("Default Value", defaultText);
+
+        LOG.debug("Using orElse:");
+        defaultText = Optional.ofNullable(text)
+            .orElse(getMyDefault());
+        assertEquals("Default Value", defaultText);
+    }
+
+    @Test
+    public void whenOrElseGetAndOrElseDiffer_thenCorrect() {
+        String text = "Text present";
+        LOG.debug("Using orElseGet:");
+        String defaultText = Optional.ofNullable(text)
+            .orElseGet(this::getMyDefault);
+        assertEquals("Text present", defaultText);
+
+        LOG.debug("Using orElse:");
+        defaultText = Optional.ofNullable(text)
+            .orElse(getMyDefault());
+        assertEquals("Text present", defaultText);
+    }
+
+    // Exceptions With orElseThrow
+    @Test(expected = IllegalArgumentException.class)
+    public void whenOrElseThrowWorks_thenCorrect() {
+        String nullName = null;
+        String name = Optional.ofNullable(nullName)
+            .orElseThrow(IllegalArgumentException::new);
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void whenNoArgOrElseThrowWorks_thenCorrect() {
+        String nullName = null;
+        String name = Optional.ofNullable(nullName).orElseThrow();
+    }
+
+    public String getMyDefault() {
+        LOG.debug("Getting default value...");
+        return "Default Value";
+    }
+    
+//    Uncomment code when code base is compatible with Java 11
+//    @Test
+//    public void givenAnEmptyOptional_thenIsEmptyBehavesAsExpected() {
+//        Optional<String> opt = Optional.of("Baeldung");
+//        assertFalse(opt.isEmpty());
+//     
+//        opt = Optional.ofNullable(null);
+//        assertTrue(opt.isEmpty());
+//    }
+
+}
@@ -0,0 +1,77 @@
+package com.baeldung.reflection;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertThat;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import org.junit.Test;
+
+public class OperationsUnitTest {
+
+    public OperationsUnitTest() {
+    }
+
+    @Test(expected = IllegalAccessException.class)
+    public void givenObject_whenInvokePrivateMethod_thenFail() throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+        Method andPrivateMethod = Operations.class.getDeclaredMethod("privateAnd", boolean.class, boolean.class);
+
+        Operations operationsInstance = new Operations();
+        Boolean result = (Boolean) andPrivateMethod.invoke(operationsInstance, true, false);
+
+        assertFalse(result);
+    }
+
+    @Test
+    public void givenObject_whenInvokePrivateMethod_thenCorrect() throws Exception {
+        Method andPrivatedMethod = Operations.class.getDeclaredMethod("privateAnd", boolean.class, boolean.class);
+        andPrivatedMethod.setAccessible(true);
+
+        Operations operationsInstance = new Operations();
+        Boolean result = (Boolean) andPrivatedMethod.invoke(operationsInstance, true, false);
+
+        assertFalse(result);
+    }
+    
+    @Test
+    public void givenObject_whenInvokePrivateMethod_thenCheckAccess() throws Exception {
+        Operations operationsInstance = new Operations();
+        Method andPrivatedMethod = Operations.class.getDeclaredMethod("privateAnd", boolean.class, boolean.class);
+        boolean isAccessEnabled = andPrivatedMethod.canAccess(operationsInstance);
+        
+        assertFalse(isAccessEnabled);
+    }
+    
+    @Test
+    public void givenObject_whenInvokePublicMethod_thenEnableAccess() throws Exception {
+        Operations operationsInstance = new Operations();
+        Method andPrivatedMethod = Operations.class.getDeclaredMethod("privateAnd", boolean.class, boolean.class);
+        andPrivatedMethod.trySetAccessible();
+        boolean isAccessEnabled = andPrivatedMethod.canAccess(operationsInstance);
+        
+        assertTrue(isAccessEnabled);
+    }
+
+    @Test
+    public void givenObject_whenInvokePublicMethod_thenCorrect() throws Exception {
+        Method sumInstanceMethod = Operations.class.getMethod("publicSum", int.class, double.class);
+
+        Operations operationsInstance = new Operations();
+        Double result = (Double) sumInstanceMethod.invoke(operationsInstance, 1, 3);
+
+        assertThat(result, equalTo(4.0));
+    }
+
+    @Test
+    public void givenObject_whenInvokeStaticMethod_thenCorrect() throws Exception {
+        Method multiplyStaticMethod = Operations.class.getDeclaredMethod("publicStaticMultiply", float.class, long.class);
+
+        Double result = (Double) multiplyStaticMethod.invoke(null, 3.5f, 2);
+
+        assertThat(result, equalTo(7.0));
+    }
+
+}
@@ -0,0 +1,295 @@
+package com.baeldung.reflection;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Test;
+
+public class ReflectionUnitTest {
+
+    @Test
+    public void givenObject_whenGetsFieldNamesAtRuntime_thenCorrect() {
+        final Object person = new Person();
+        final Field[] fields = person.getClass().getDeclaredFields();
+
+        final List<String> actualFieldNames = getFieldNames(fields);
+
+        assertTrue(Arrays.asList("name", "age").containsAll(actualFieldNames));
+    }
+
+    @Test
+    public void givenObject_whenGetsClassName_thenCorrect() {
+        final Object goat = new Goat("goat");
+        final Class<?> clazz = goat.getClass();
+
+        assertEquals("Goat", clazz.getSimpleName());
+        assertEquals("com.baeldung.reflection.Goat", clazz.getName());
+        assertEquals("com.baeldung.reflection.Goat", clazz.getCanonicalName());
+    }
+
+    @Test
+    public void givenClassName_whenCreatesObject_thenCorrect() throws ClassNotFoundException {
+        final Class<?> clazz = Class.forName("com.baeldung.reflection.Goat");
+
+        assertEquals("Goat", clazz.getSimpleName());
+        assertEquals("com.baeldung.reflection.Goat", clazz.getName());
+        assertEquals("com.baeldung.reflection.Goat", clazz.getCanonicalName());
+    }
+
+    @Test
+    public void givenClass_whenRecognisesModifiers_thenCorrect() throws ClassNotFoundException {
+        final Class<?> goatClass = Class.forName("com.baeldung.reflection.Goat");
+        final Class<?> animalClass = Class.forName("com.baeldung.reflection.Animal");
+        final int goatMods = goatClass.getModifiers();
+        final int animalMods = animalClass.getModifiers();
+
+        assertTrue(Modifier.isPublic(goatMods));
+        assertTrue(Modifier.isAbstract(animalMods));
+        assertTrue(Modifier.isPublic(animalMods));
+    }
+
+    @Test
+    public void givenClass_whenGetsPackageInfo_thenCorrect() {
+        final Goat goat = new Goat("goat");
+        final Class<?> goatClass = goat.getClass();
+        final Package pkg = goatClass.getPackage();
+
+        assertEquals("com.baeldung.reflection", pkg.getName());
+    }
+
+    @Test
+    public void givenClass_whenGetsSuperClass_thenCorrect() {
+        final Goat goat = new Goat("goat");
+        final String str = "any string";
+
+        final Class<?> goatClass = goat.getClass();
+        final Class<?> goatSuperClass = goatClass.getSuperclass();
+
+        assertEquals("Animal", goatSuperClass.getSimpleName());
+        assertEquals("Object", str.getClass().getSuperclass().getSimpleName());
+
+    }
+
+    @Test
+    public void givenClass_whenGetsImplementedInterfaces_thenCorrect() throws ClassNotFoundException {
+        final Class<?> goatClass = Class.forName("com.baeldung.reflection.Goat");
+        final Class<?> animalClass = Class.forName("com.baeldung.reflection.Animal");
+        final Class<?>[] goatInterfaces = goatClass.getInterfaces();
+        final Class<?>[] animalInterfaces = animalClass.getInterfaces();
+
+        assertEquals(1, goatInterfaces.length);
+        assertEquals(1, animalInterfaces.length);
+        assertEquals("Locomotion", goatInterfaces[0].getSimpleName());
+        assertEquals("Eating", animalInterfaces[0].getSimpleName());
+    }
+
+    @Test
+    public void givenClass_whenGetsConstructor_thenCorrect() throws ClassNotFoundException {
+        final Class<?> goatClass = Class.forName("com.baeldung.reflection.Goat");
+        final Constructor<?>[] constructors = goatClass.getConstructors();
+
+        assertEquals(1, constructors.length);
+        assertEquals("com.baeldung.reflection.Goat", constructors[0].getName());
+    }
+
+    @Test
+    public void givenClass_whenGetsFields_thenCorrect() throws ClassNotFoundException {
+        final Class<?> animalClass = Class.forName("com.baeldung.reflection.Animal");
+        final Field[] fields = animalClass.getDeclaredFields();
+
+        final List<String> actualFields = getFieldNames(fields);
+
+        assertEquals(2, actualFields.size());
+        assertTrue(actualFields.containsAll(Arrays.asList("name", "CATEGORY")));
+    }
+
+    @Test
+    public void givenClass_whenGetsMethods_thenCorrect() throws ClassNotFoundException {
+        final Class<?> animalClass = Class.forName("com.baeldung.reflection.Animal");
+        final Method[] methods = animalClass.getDeclaredMethods();
+        final List<String> actualMethods = getMethodNames(methods);
+
+        assertEquals(3, actualMethods.size());
+        assertTrue(actualMethods.containsAll(Arrays.asList("getName", "setName", "getSound")));
+    }
+
+    @Test
+    public void givenClass_whenGetsAllConstructors_thenCorrect() throws ClassNotFoundException {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Constructor<?>[] constructors = birdClass.getConstructors();
+
+        assertEquals(3, constructors.length);
+    }
+
+    @Test
+    public void givenClass_whenGetsEachConstructorByParamTypes_thenCorrect() throws Exception {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        birdClass.getConstructor();
+        birdClass.getConstructor(String.class);
+        birdClass.getConstructor(String.class, boolean.class);
+    }
+
+    @Test
+    public void givenClass_whenInstantiatesObjectsAtRuntime_thenCorrect() throws Exception {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+
+        final Constructor<?> cons1 = birdClass.getConstructor();
+        final Constructor<?> cons2 = birdClass.getConstructor(String.class);
+        final Constructor<?> cons3 = birdClass.getConstructor(String.class, boolean.class);
+
+        final Bird bird1 = (Bird) cons1.newInstance();
+        final Bird bird2 = (Bird) cons2.newInstance("Weaver bird");
+        final Bird bird3 = (Bird) cons3.newInstance("dove", true);
+
+        assertEquals("bird", bird1.getName());
+        assertEquals("Weaver bird", bird2.getName());
+        assertEquals("dove", bird3.getName());
+        assertFalse(bird1.walks());
+        assertTrue(bird3.walks());
+    }
+
+    @Test
+    public void givenClass_whenGetsPublicFields_thenCorrect() throws ClassNotFoundException {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Field[] fields = birdClass.getFields();
+        assertEquals(1, fields.length);
+        assertEquals("CATEGORY", fields[0].getName());
+
+    }
+
+    @Test
+    public void givenClass_whenGetsPublicFieldByName_thenCorrect() throws Exception {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Field field = birdClass.getField("CATEGORY");
+        assertEquals("CATEGORY", field.getName());
+
+    }
+
+    @Test
+    public void givenClass_whenGetsDeclaredFields_thenCorrect() throws ClassNotFoundException {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Field[] fields = birdClass.getDeclaredFields();
+        assertEquals(1, fields.length);
+        assertEquals("walks", fields[0].getName());
+    }
+
+    @Test
+    public void givenClass_whenGetsFieldsByName_thenCorrect() throws Exception {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Field field = birdClass.getDeclaredField("walks");
+        assertEquals("walks", field.getName());
+
+    }
+
+    @Test
+    public void givenClassField_whenGetsType_thenCorrect() throws Exception {
+        final Field field = Class.forName("com.baeldung.reflection.Bird").getDeclaredField("walks");
+        final Class<?> fieldClass = field.getType();
+        assertEquals("boolean", fieldClass.getSimpleName());
+    }
+
+    @Test
+    public void givenClassField_whenSetsAndGetsValue_thenCorrect() throws Exception {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Bird bird = (Bird) birdClass.getConstructor().newInstance();
+        final Field field = birdClass.getDeclaredField("walks");
+        field.setAccessible(true);
+
+        assertFalse(field.getBoolean(bird));
+        assertFalse(bird.walks());
+
+        field.set(bird, true);
+
+        assertTrue(field.getBoolean(bird));
+        assertTrue(bird.walks());
+
+    }
+
+    @Test
+    public void givenClassField_whenGetsAndSetsWithNull_thenCorrect() throws Exception {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Field field = birdClass.getField("CATEGORY");
+        field.setAccessible(true);
+
+        assertEquals("domestic", field.get(null));
+    }
+
+    @Test
+    public void givenClass_whenGetsAllPublicMethods_thenCorrect() throws ClassNotFoundException {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Method[] methods = birdClass.getMethods();
+        final List<String> methodNames = getMethodNames(methods);
+
+        assertTrue(methodNames.containsAll(Arrays.asList("equals", "notifyAll", "hashCode", "walks", "eats", "toString")));
+
+    }
+
+    @Test
+    public void givenClass_whenGetsOnlyDeclaredMethods_thenCorrect() throws ClassNotFoundException {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final List<String> actualMethodNames = getMethodNames(birdClass.getDeclaredMethods());
+
+        final List<String> expectedMethodNames = Arrays.asList("setWalks", "walks", "getSound", "eats");
+
+        assertEquals(expectedMethodNames.size(), actualMethodNames.size());
+        assertTrue(expectedMethodNames.containsAll(actualMethodNames));
+        assertTrue(actualMethodNames.containsAll(expectedMethodNames));
+
+    }
+
+    @Test
+    public void givenMethodName_whenGetsMethod_thenCorrect() throws Exception {
+        final Bird bird = new Bird();
+        final Method walksMethod = bird.getClass().getDeclaredMethod("walks");
+        final Method setWalksMethod = bird.getClass().getDeclaredMethod("setWalks", boolean.class);
+
+        assertTrue(walksMethod.canAccess(bird));
+        assertTrue(setWalksMethod.canAccess(bird));
+    }
+
+    @Test
+    public void givenMethod_whenInvokes_thenCorrect() throws Exception {
+        final Class<?> birdClass = Class.forName("com.baeldung.reflection.Bird");
+        final Bird bird = (Bird) birdClass.getConstructor().newInstance();
+        final Method setWalksMethod = birdClass.getDeclaredMethod("setWalks", boolean.class);
+        final Method walksMethod = birdClass.getDeclaredMethod("walks");
+        final boolean walks = (boolean) walksMethod.invoke(bird);
+
+        assertFalse(walks);
+        assertFalse(bird.walks());
+
+        setWalksMethod.invoke(bird, true);
+        final boolean walks2 = (boolean) walksMethod.invoke(bird);
+
+        assertTrue(walks2);
+        assertTrue(bird.walks());
+
+    }
+
+    private static List<String> getFieldNames(Field[] fields) {
+        final List<String> fieldNames = new ArrayList<>();
+        for (final Field field : fields) {
+            fieldNames.add(field.getName());
+        }
+        return fieldNames;
+
+    }
+
+    private static List<String> getMethodNames(Method[] methods) {
+        final List<String> methodNames = new ArrayList<>();
+        for (final Method method : methods) {
+            methodNames.add(method.getName());
+        }
+        return methodNames;
+    }
+
+}
@@ -0,0 +1,49 @@
+package com.baeldung.version;
+
+import org.apache.commons.lang3.SystemUtils;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+// manual test as the runtime JDK version can be different depending on where the test is run
+public class VersionManualTest {
+
+    @Test
+    public void givenJava_whenUsingRuntime_thenGetVersion() {
+        String expectedVersion = "15";
+        Runtime.Version runtimeVersion = Runtime.version();
+        String version = String.valueOf(runtimeVersion.version().get(0));
+        Assertions.assertThat(version).isEqualTo(expectedVersion);
+    }
+
+    @Test
+    @Disabled("Only valid for Java 8 and lower")
+    public void givenJava_whenUsingCommonsLang_thenGetVersion() {
+        int expectedVersion = 8;
+        String[] versionElements = SystemUtils.JAVA_SPECIFICATION_VERSION.split("\\.");
+        int discard = Integer.parseInt(versionElements[0]);
+        int version;
+        if (discard == 1) {
+            version = Integer.parseInt(versionElements[1]);
+        } else {
+            version = discard;
+        }
+        Assertions.assertThat(version).isEqualTo(expectedVersion);
+    }
+
+    @Test
+    @Disabled("Only valid for Java 8 and lower")
+    public void givenJava_whenUsingSystemProp_thenGetVersion() {
+        int expectedVersion = 8;
+        String[] versionElements = System.getProperty("java.version").split("\\.");
+        int discard = Integer.parseInt(versionElements[0]);
+        int version;
+        if (discard == 1) {
+            version = Integer.parseInt(versionElements[1]);
+        } else {
+            version = discard;
+        }
+        Assertions.assertThat(version).isEqualTo(expectedVersion);
+    }
+}
+
@@ -0,0 +1,8 @@
+## Core Java 11
+
+This module contains articles about Java 11 core features
+
+### Relevant articles
+- [Adding Parameters to Java HttpClient Requests](https://www.baeldung.com/java-httpclient-request-parameters)
+- [Writing a List of Strings Into a Text File](https://www.baeldung.com/java-list-to-text-file)
+- [Java HttpClient – Map JSON Response to Java Class](https://www.baeldung.com/java-httpclient-map-json-response)
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-11-3</artifactId>
+    <packaging>jar</packaging>
+    <name>core-java-11-3</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>${gson.version}</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source.version}</source>
+                    <target>${maven.compiler.target.version}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source.version>11</maven.compiler.source.version>
+        <maven.compiler.target.version>11</maven.compiler.target.version>
+        <gson.version>2.10.1</gson.version>
+    </properties>
+
+</project>
@@ -0,0 +1,19 @@
+package com.baeldung.filewriter;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.List;
+
+public class BufferedWriterExample {
+
+    public static String generateFileFromStringList(List<String> stringList) throws IOException {
+        final String TEXT_FILENAME = "src/test/resources/sampleTextFile.txt";
+        BufferedWriter br = new BufferedWriter(new FileWriter(TEXT_FILENAME));
+        for (String str : stringList) {
+            br.write(str + System.lineSeparator());
+        }
+        br.close();
+        return TEXT_FILENAME;
+    }
+}
@@ -0,0 +1,22 @@
+package com.baeldung.filewriter;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.List;
+
+public class FileWriteStringExample {
+    public static String generateFileFromStringList(List<String> stringList) throws IOException {
+        final String TEXT_FILENAME = "src/test/resources/sampleTextFile.txt";
+        Path filePath = Paths.get(TEXT_FILENAME);
+        Files.deleteIfExists(filePath);
+        Files.createFile(filePath);
+        for (String str : stringList) {
+            Files.writeString(filePath, str + System.lineSeparator(),
+                    StandardOpenOption.APPEND);
+        }
+        return filePath.toString();
+    }
+}
@@ -0,0 +1,18 @@
+package com.baeldung.filewriter;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.List;
+
+public class FileWriterExample {
+
+    public static String generateFileFromStringList(List<String> stringList) throws IOException {
+        final String TEXT_FILENAME = "src/test/resources/sampleTextFile.txt";
+        FileWriter fileWriter = new FileWriter(TEXT_FILENAME);
+        for (String str : stringList) {
+            fileWriter.write(str + System.lineSeparator());
+        }
+        fileWriter.close();
+        return TEXT_FILENAME;
+    }
+}
@@ -0,0 +1,73 @@
+package com.baeldung.httppojo;
+
+import java.util.Objects;
+
+public class Todo {
+
+    int userId;
+    int id;
+    String title;
+    boolean completed;
+
+    public Todo() {
+    }
+
+    public Todo(int userId, int id, String title, boolean completed) {
+        this.userId = userId;
+        this.id = id;
+        this.title = title;
+        this.completed = completed;
+    }
+
+    public int getUserId() {
+        return userId;
+    }
+
+    public void setUserId(int userId) {
+        this.userId = userId;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title = title;
+    }
+
+    public boolean isCompleted() {
+        return completed;
+    }
+
+    public void setCompleted(boolean completed) {
+        this.completed = completed;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+        Todo todo = (Todo) o;
+        return userId == todo.userId && id == todo.id && completed == todo.completed && Objects.equals(title, todo.title);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(userId, id, title, completed);
+    }
+
+    @Override
+    public String toString() {
+        return "{" + "userId=" + userId + ", id=" + id + ", title='" + title + '\'' + ", completed=" + completed + '}';
+    }
+}
@@ -0,0 +1,107 @@
+package com.baeldung.httppojo;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.util.List;
+import java.util.concurrent.CompletionException;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+
+public class TodoAppClient {
+
+    ObjectMapper objectMapper = new ObjectMapper();
+
+    Gson gson = new GsonBuilder().create();
+
+    public String sampleApiRequest() throws Exception {
+        HttpClient client = HttpClient.newHttpClient();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(URI.create("https://jsonplaceholder.typicode.com/todos"))
+            .build();
+
+        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
+
+        return response.body();
+
+    }
+
+    public Todo syncGson() throws Exception {
+        String response = sampleApiRequest();
+
+        List<Todo> todo = gson.fromJson(response, new TypeToken<List<Todo>>() {
+        }.getType());
+
+        return todo.get(1);
+
+    }
+
+    public Todo syncJackson() throws Exception {
+        String response = sampleApiRequest();
+
+        Todo[] todo = objectMapper.readValue(response, Todo[].class);
+
+        return todo[1];
+
+    }
+
+    public Todo asyncJackson() throws Exception {
+
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(URI.create("https://jsonplaceholder.typicode.com/todos"))
+            .build();
+
+        TodoAppClient todoAppClient = new TodoAppClient();
+
+        List<Todo> todo = HttpClient.newHttpClient()
+            .sendAsync(request, BodyHandlers.ofString())
+            .thenApply(HttpResponse::body)
+            .thenApply(todoAppClient::readValueJackson)
+            .get();
+
+        return todo.get(1);
+
+    }
+
+    public Todo asyncGson() throws Exception {
+
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(URI.create("https://jsonplaceholder.typicode.com/todos"))
+            .build();
+        TodoAppClient todoAppClient = new TodoAppClient();
+
+        List<Todo> todo = HttpClient.newHttpClient()
+            .sendAsync(request, BodyHandlers.ofString())
+            .thenApply(HttpResponse::body)
+            .thenApply(todoAppClient::readValueGson)
+            .get();
+
+        return todo.get(1);
+
+    }
+
+    List<Todo> readValueJackson(String content) {
+
+        try {
+            return objectMapper.readValue(content, new TypeReference<List<Todo>>() {
+            });
+        } catch (IOException ioe) {
+            throw new CompletionException(ioe);
+        }
+    }
+    
+    List<Todo> readValueGson(String content) {
+
+        return gson.fromJson(content, new TypeToken<List<Todo>>() {
+        }.getType());
+
+    }
+
+}
@@ -0,0 +1,22 @@
+package com.baeldung.filewriter;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.Assert.assertTrue;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+
+public class BufferedWriterUnitTest {
+
+    private static final List<String> stringList = Arrays.asList("Hello", "World");
+
+    @Test
+    public void givenUsingBufferedWriter_whenStringList_thenGetTextFile() throws IOException {
+        String fileName = BufferedWriterExample.generateFileFromStringList(stringList);
+        long count = Files.lines(Paths.get(fileName)).count();
+        assertTrue("No. of lines in file should be equal to no. of Strings in List", ((int) count) == stringList.size());
+    }
+}
@@ -0,0 +1,23 @@
+package com.baeldung.filewriter;
+
+import org.junit.jupiter.api.Test;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+
+public class FileWriteStringUnitTest {
+
+    private static final List<String> stringList = Arrays.asList("Hello", "World");
+
+    @Test
+    public void givenUsingFileWriteString_whenStringList_thenGetTextFile() throws IOException {
+        String fileName = FileWriteStringExample.generateFileFromStringList(stringList);
+        long count = Files.lines(Paths.get(fileName)).count();
+        assertTrue("No. of lines in file should be equal to no. of Strings in List", ((int) count) == stringList.size());
+    }
+}
@@ -0,0 +1,23 @@
+package com.baeldung.filewriter;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+public class FileWriterUnitTest {
+
+    private static final List<String> stringList = Arrays.asList("Hello", "World");
+
+    @Test
+    public void givenUsingFileWriter_whenStringList_thenGetTextFile() throws IOException {
+        String fileName = FileWriterExample.generateFileFromStringList(stringList);
+        long count = Files.lines(Paths.get(fileName)).count();
+        assertTrue("No. of lines in file should be equal to no. of Strings in List", ((int) count) == stringList.size());
+    }
+}
@@ -0,0 +1,45 @@
+package com.baeldung.httpclient.parameters;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class HttpClientParametersLiveTest {
+
+    private static HttpClient client;
+
+    @BeforeAll
+    public static void setUp() {
+        client = HttpClient.newHttpClient();
+    }
+
+    @Test
+    public void givenQueryParams_whenGetRequest_thenResponseOk() throws IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+          .version(HttpClient.Version.HTTP_2)
+          .uri(URI.create("https://postman-echo.com/get?param1=value1&param2=value2"))
+          .GET()
+          .build();
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertEquals(response.statusCode(), 200);
+    }
+
+    @Test
+    public void givenQueryParams_whenGetRequestWithDefaultConfiguration_thenResponseOk() throws IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+          .uri(URI.create("https://postman-echo.com/get?param1=value1&param2=value2"))
+          .build();
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertEquals(response.statusCode(), 200);
+    }
+
+}
@@ -0,0 +1,45 @@
+package com.baeldung.httppojo;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class HttpClientPojoClassUnitTest {
+
+    Todo expectedTodo = new Todo(1, 2, "quis ut nam facilis et officia qui", false);
+
+    @Test
+    public void givenSampleApiCall_whenResponseIsMappedByGson_thenCompareResponseMappedByGson() throws Exception {
+        TodoAppClient sampleGson = new TodoAppClient();
+
+        assertEquals(expectedTodo, sampleGson.syncGson());
+
+    }
+
+    @Test
+    public void givenSampleApiCall_whenResponseIsMappedByJackson_thenCompareResponseMappedByJackson() throws Exception {
+        TodoAppClient sampleJackson = new TodoAppClient();
+
+        assertEquals(expectedTodo, sampleJackson.syncJackson());
+    }
+
+    @Test
+    public void givenSampleRestApi_whenApiIsConsumedByHttpClient_thenCompareJsonString() throws Exception {
+        TodoAppClient sampleTest = new TodoAppClient();
+        assertNotNull(sampleTest.sampleApiRequest());
+
+    }
+
+    @Test
+    public void givenSampleApiAsyncCall_whenResponseIsMappedByJackson_thenCompareResponseMappedByJackson() throws Exception {
+        TodoAppClient sampleAsynJackson = new TodoAppClient();
+        assertEquals(expectedTodo, sampleAsynJackson.asyncJackson());
+    }
+
+    @Test
+    public void givenSampleApiAsyncCall_whenResponseIsMappedByGson_thenCompareResponseMappedByGson() throws Exception {
+        TodoAppClient sampleAsynGson = new TodoAppClient();
+        assertEquals(expectedTodo, sampleAsynGson.asyncGson());
+    }
+
+}
@@ -0,0 +1,2 @@
+Hello
+World
@@ -0,0 +1,13 @@
+package com.baeldung;
+
+/**
+ * Hello world!
+ *
+ */
+public class App 
+{
+    public static void main( String[] args )
+    {
+        System.out.println( "Hello World!" );
+    }
+}
@@ -0,0 +1,24 @@
+package com.baeldung;
+
+import java.lang.reflect.Method;
+
+public class Outer {
+
+    public void outerPublic() {
+    }
+
+    private void outerPrivate() {
+    }
+
+    class Inner {
+
+        public void innerPublic() {
+            outerPrivate();
+        }
+
+        public void innerPublicReflection(Outer ob) throws Exception {
+            Method method = ob.getClass().getDeclaredMethod("outerPrivate");
+            method.invoke(ob);
+        }
+    }
+}
@@ -0,0 +1,4 @@
+package com.baeldung;
+
+public class Unrelated {
+}
@@ -0,0 +1,12 @@
+#!/usr/local/bin/java --source 11
+
+import java.util.Arrays;
+
+public class Addition
+{
+    public static void main(String[] args) {
+        System.out.println(Arrays.stream(args)
+          .mapToInt(Integer::parseInt)
+          .sum());
+    }
+}
@@ -0,0 +1,70 @@
+package com.baeldung.benchmark;
+
+import org.eclipse.collections.api.list.MutableList;
+import org.eclipse.collections.api.list.primitive.IntList;
+import org.eclipse.collections.api.list.primitive.MutableIntList;
+import org.eclipse.collections.impl.factory.primitive.IntLists;
+import org.eclipse.collections.impl.list.mutable.FastList;
+import org.eclipse.collections.impl.list.mutable.primitive.IntArrayList;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.PrimitiveIterator;
+import java.util.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@Fork(2)
+public class IntegerListFilter {
+
+    private List<Integer> jdkIntList;
+    private MutableList<Integer> ecMutableList;
+    private IntList ecIntList;
+    private ExecutorService executor;
+
+    @Setup
+    public void setup() {
+        PrimitiveIterator.OfInt iterator = new Random(1L).ints(-10000, 10000).iterator();
+        ecMutableList = FastList.newWithNValues(1_000_000, iterator::nextInt);
+        jdkIntList = new ArrayList<>(1_000_000);
+        jdkIntList.addAll(ecMutableList);
+        ecIntList = ecMutableList.collectInt(i -> i, new IntArrayList(1_000_000));
+        executor = Executors.newWorkStealingPool();
+    }
+
+    @Benchmark
+    public List<Integer> jdkList() {
+        return jdkIntList.stream().filter(i -> i % 5 == 0).collect(Collectors.toList());
+    }
+
+    @Benchmark
+    public MutableList<Integer> ecMutableList() {
+        return ecMutableList.select(i -> i % 5 == 0);
+    }
+
+    @Benchmark
+    public List<Integer> jdkListParallel() {
+        return jdkIntList.parallelStream().filter(i -> i % 5 == 0).collect(Collectors.toList());
+    }
+
+    @Benchmark
+    public MutableList<Integer> ecMutableListParallel() {
+        return ecMutableList.asParallel(executor, 100_000).select(i -> i % 5 == 0).toList();
+    }
+
+    @Benchmark
+    public IntList ecPrimitive() {
+        return this.ecIntList.select(i -> i % 5 == 0);
+    }
+
+    @Benchmark
+    public IntList ecPrimitiveParallel() {
+        return this.ecIntList.primitiveParallelStream().filter(i -> i % 5 == 0).collect(IntLists.mutable::empty, MutableIntList::add, MutableIntList::addAll);
+    }
+}
@@ -0,0 +1,67 @@
+package com.baeldung.benchmark;
+
+import org.eclipse.collections.api.list.MutableList;
+import org.eclipse.collections.api.list.primitive.IntList;
+import org.eclipse.collections.impl.list.mutable.FastList;
+import org.eclipse.collections.impl.list.mutable.primitive.IntArrayList;
+import org.openjdk.jmh.annotations.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.PrimitiveIterator;
+import java.util.Random;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+@State(Scope.Benchmark)
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.SECONDS)
+@Fork(2)
+public class IntegerListSum {
+
+    private List<Integer> jdkIntList;
+    private MutableList<Integer> ecMutableList;
+    private ExecutorService executor;
+    private IntList ecIntList;
+
+    @Setup
+    public void setup() {
+        PrimitiveIterator.OfInt iterator = new Random(1L).ints(-10000, 10000).iterator();
+        ecMutableList = FastList.newWithNValues(1_000_000, iterator::nextInt);
+        jdkIntList = new ArrayList<>(1_000_000);
+        jdkIntList.addAll(ecMutableList);
+        ecIntList = ecMutableList.collectInt(i -> i, new IntArrayList(1_000_000));
+        executor = Executors.newWorkStealingPool();
+    }
+
+    @Benchmark
+    public long jdkList() {
+        return jdkIntList.stream().mapToLong(i -> i).sum();
+    }
+
+    @Benchmark
+    public long ecMutableList() {
+        return ecMutableList.sumOfInt(i -> i);
+    }
+
+    @Benchmark
+    public long jdkListParallel() {
+        return jdkIntList.parallelStream().mapToLong(i -> i).sum();
+    }
+
+    @Benchmark
+    public long ecMutableListParallel() {
+        return ecMutableList.asParallel(executor, 100_000).sumOfInt(i -> i);
+    }
+
+    @Benchmark
+    public long ecPrimitive() {
+        return this.ecIntList.sum();
+    }
+
+    @Benchmark
+    public long ecPrimitiveParallel() {
+        return this.ecIntList.primitiveParallelStream().sum();
+    }
+}
@@ -0,0 +1,18 @@
+package com.baeldung.epsilongc;
+
+public class MemoryPolluter {
+
+    private static final int MEGABYTE_IN_BYTES = 1024 * 1024;
+    private static final int ITERATION_COUNT = 1024 * 10;
+
+    public static void main(String[] args) {
+        System.out.println("Starting pollution");
+
+        for (int i = 0; i < ITERATION_COUNT; i++) {
+            byte[] array = new byte[MEGABYTE_IN_BYTES];
+        }
+
+        System.out.println("Terminating");
+    }
+
+}
@@ -0,0 +1,132 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.baeldung.java11.httpclient;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpClient.Version;
+import java.net.http.HttpRequest;
+import java.net.http.HttpRequest.BodyPublishers;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.net.http.HttpResponse.PushPromiseHandler;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class HttpClientExample {
+
+    public static void main(String[] args) throws Exception {
+        httpGetRequest();
+        httpPostRequest();
+        asynchronousGetRequest();
+        asynchronousMultipleRequests();
+        pushRequest();
+    }
+
+    public static void httpGetRequest() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient.newHttpClient();
+        HttpRequest request = HttpRequest.newBuilder()
+            .version(HttpClient.Version.HTTP_2)
+            .uri(URI.create("http://jsonplaceholder.typicode.com/posts/1"))
+            .headers("Accept-Enconding", "gzip, deflate")
+            .build();
+        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
+
+        String responseBody = response.body();
+        int responseStatusCode = response.statusCode();
+
+        System.out.println("httpGetRequest: " + responseBody);
+        System.out.println("httpGetRequest status code: " + responseStatusCode);
+    }
+
+    public static void httpPostRequest() throws URISyntaxException, IOException, InterruptedException {
+        HttpClient client = HttpClient.newBuilder()
+            .version(HttpClient.Version.HTTP_2)
+            .build();
+        HttpRequest request = HttpRequest.newBuilder(new URI("http://jsonplaceholder.typicode.com/posts"))
+            .version(HttpClient.Version.HTTP_2)
+            .POST(BodyPublishers.ofString("Sample Post Request"))
+            .build();
+        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
+        String responseBody = response.body();
+        System.out.println("httpPostRequest : " + responseBody);
+    }
+
+    public static void asynchronousGetRequest() throws URISyntaxException {
+        HttpClient client = HttpClient.newHttpClient();
+        URI httpURI = new URI("http://jsonplaceholder.typicode.com/posts/1");
+        HttpRequest request = HttpRequest.newBuilder(httpURI)
+            .version(HttpClient.Version.HTTP_2)
+            .build();
+        CompletableFuture<Void> futureResponse = client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
+            .thenAccept(resp -> {
+                System.out.println("Got pushed response " + resp.uri());
+                System.out.println("Response statuscode: " + resp.statusCode());
+                System.out.println("Response body: " + resp.body());
+            });
+        System.out.println("futureResponse" + futureResponse);
+
+    }
+
+    public static void asynchronousMultipleRequests() throws URISyntaxException {
+        HttpClient client = HttpClient.newHttpClient();
+        List<URI> uris = Arrays.asList(new URI("http://jsonplaceholder.typicode.com/posts/1"), new URI("http://jsonplaceholder.typicode.com/posts/2"));
+        List<HttpRequest> requests = uris.stream()
+            .map(HttpRequest::newBuilder)
+            .map(reqBuilder -> reqBuilder.build())
+            .collect(Collectors.toList());
+        System.out.println("Got pushed response1 " + requests);
+        CompletableFuture.allOf(requests.stream()
+            .map(request -> client.sendAsync(request, BodyHandlers.ofString()))
+            .toArray(CompletableFuture<?>[]::new))
+            .thenAccept(System.out::println)
+            .join();
+    }
+
+    public static void pushRequest() throws URISyntaxException, InterruptedException {
+        System.out.println("Running HTTP/2 Server Push example...");
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .version(Version.HTTP_2)
+            .build();
+
+        HttpRequest pageRequest = HttpRequest.newBuilder()
+            .uri(URI.create("https://http2.golang.org/serverpush"))
+            .build();
+
+        // Interface HttpResponse.PushPromiseHandler<T>
+        // void applyPushPromise(HttpRequest initiatingRequest, HttpRequest pushPromiseRequest, Function<HttpResponse.BodyHandler<T>,CompletableFuture<HttpResponse<T>>> acceptor)
+        httpClient.sendAsync(pageRequest, BodyHandlers.ofString(), pushPromiseHandler())
+            .thenAccept(pageResponse -> {
+                System.out.println("Page response status code: " + pageResponse.statusCode());
+                System.out.println("Page response headers: " + pageResponse.headers());
+                String responseBody = pageResponse.body();
+                System.out.println(responseBody);
+            }).join();
+
+        Thread.sleep(1000); // waiting for full response
+    }
+
+    private static PushPromiseHandler<String> pushPromiseHandler() {
+        return (HttpRequest initiatingRequest, 
+            HttpRequest pushPromiseRequest, 
+            Function<HttpResponse.BodyHandler<String>, 
+            CompletableFuture<HttpResponse<String>>> acceptor) -> {
+            acceptor.apply(BodyHandlers.ofString())
+                .thenAccept(resp -> {
+                    System.out.println(" Pushed response: " + resp.uri() + ", headers: " + resp.headers());
+                });
+            System.out.println("Promise request: " + pushPromiseRequest.uri());
+            System.out.println("Promise request: " + pushPromiseRequest.headers());
+        };
+    }
+
+}
@@ -0,0 +1,19 @@
+package com.baeldung.predicate.not;
+
+public class Person {
+    private static final int ADULT_AGE = 18;
+
+    private int age;
+
+    public Person(int age) {
+        this.age = age;
+    }
+
+    public boolean isAdult() {
+        return age >= ADULT_AGE;
+    }
+
+    public boolean isNotAdult() {
+        return !isAdult();
+    }
+}
@@ -0,0 +1 @@
+
@@ -0,0 +1,38 @@
+package com.baeldung;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppUnitTest
+    extends TestCase
+{
+    /**
+     * Create the test case
+     *
+     * @param testName name of the test case
+     */
+    public AppUnitTest(String testName )
+    {
+        super( testName );
+    }
+
+    /**
+     * @return the suite of tests being tested
+     */
+    public static Test suite()
+    {
+        return new TestSuite( AppUnitTest.class );
+    }
+
+    /**
+     * Rigourous Test :-)
+     */
+    public void testApp()
+    {
+        assertTrue( true );
+    }
+}
@@ -0,0 +1,43 @@
+package com.baeldung;
+
+import static org.hamcrest.CoreMatchers.is;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class NewStringAPIUnitTest {
+
+    @Test
+    public void whenRepeatStringTwice_thenGetStringTwice() {
+        String output = "La ".repeat(2) + "Land";
+
+        is(output).equals("La La Land");
+    }
+
+    @Test
+    public void whenStripString_thenReturnStringWithoutWhitespaces() {
+        is("\n\t  hello   \u2005".strip()).equals("hello");
+    }
+
+    @Test
+    public void whenTrimAdvanceString_thenReturnStringWithWhitespaces() {
+        is("\n\t  hello   \u2005".trim()).equals("hello   \u2005");
+    }
+
+    @Test
+    public void whenBlankString_thenReturnTrue() {
+        assertTrue("\n\t\u2005  ".isBlank());
+    }
+
+    @Test
+    public void whenMultilineString_thenReturnNonEmptyLineCount() {
+        String multilineStr = "This is\n \n a multiline\n string.";
+
+        long lineCount = multilineStr.lines()
+          .filter(String::isBlank)
+          .count();
+
+        is(lineCount).equals(3L);
+    }
+}
@@ -0,0 +1,46 @@
+package com.baeldung;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+import org.junit.Test;
+
+public class OuterUnitTest {
+
+    private static final String NEST_HOST_NAME = "com.baeldung.Outer";
+
+    @Test
+    public void whenGetNestHostFromOuter_thenGetNestHost() {
+        assertEquals(NEST_HOST_NAME, Outer.class.getNestHost().getName());
+    }
+
+    @Test
+    public void whenGetNestHostFromInner_thenGetNestHost() {
+        assertEquals(NEST_HOST_NAME, Outer.Inner.class.getNestHost().getName());
+    }
+
+    @Test
+    public void whenCheckNestmatesForNestedClasses_thenGetTrue() {
+        assertTrue(Outer.Inner.class.isNestmateOf(Outer.class));
+    }
+
+    @Test
+    public void whenCheckNestmatesForUnrelatedClasses_thenGetFalse() {
+        assertFalse(Outer.Inner.class.isNestmateOf(Unrelated.class));
+    }
+
+    @Test
+    public void whenGetNestMembersForNestedClasses_thenGetAllNestedClasses() {
+        Set<String> nestMembers = Arrays.stream(Outer.Inner.class.getNestMembers())
+          .map(Class::getName)
+          .collect(Collectors.toSet());
+
+        is(nestMembers.size()).equals(2);
+
+        assertTrue(nestMembers.contains("com.baeldung.Outer"));
+        assertTrue(nestMembers.contains("com.baeldung.Outer$Inner"));
+    }
+}
@@ -0,0 +1,33 @@
+package com.baeldung.benchmark;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+
+public class IntegerListFilterUnitTest {
+
+    private IntegerListFilter integerListFilter;
+
+    @Before
+    public void init() {
+        integerListFilter = new IntegerListFilter();
+        integerListFilter.setup();
+    }
+
+    @Test
+    public void whenBenchmarkIsExecute_thenJDKListsMustBeOfSameSize() {
+        assertEquals(integerListFilter.jdkList().size(), integerListFilter.jdkListParallel().size());
+    }
+
+    @Test
+    public void whenBenchmarkIsExecute_thenMutableListsMustBeOfSameSize() {
+        assertEquals(integerListFilter.ecMutableList().size(), integerListFilter.ecMutableListParallel().size());
+    }
+
+    @Test
+    public void whenBenchmarkIsExecute_thenPrimitiveListsMustBeOfSameSize() {
+        assertEquals(integerListFilter.ecPrimitive().size(), integerListFilter.ecPrimitiveParallel().size());
+    }
+}
@@ -0,0 +1,33 @@
+package com.baeldung.benchmark;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+
+public class IntegerListSumUnitTest {
+
+    private IntegerListSum integerListSum;
+
+    @Before
+    public void init() {
+        integerListSum = new IntegerListSum();
+        integerListSum.setup();
+    }
+
+    @Test
+    public void whenBenchmarkIsExecute_thenJDKListsMustHaveSameValue() {
+        assertEquals(integerListSum.jdkList(), integerListSum.jdkListParallel());
+    }
+
+    @Test
+    public void whenBenchmarkIsExecute_thenMutableListsMustHaveSameValue() {
+        assertEquals(integerListSum.ecMutableList(), integerListSum.ecMutableListParallel());
+    }
+
+    @Test
+    public void whenBenchmarkIsExecute_thenPrimitiveListsMustHaveSameValue() {
+        assertEquals(integerListSum.ecPrimitive(), integerListSum.ecPrimitiveParallel());
+    }
+}
@@ -0,0 +1,240 @@
+package com.baeldung.java11.httpclient.test;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.io.IOException;
+import java.net.Authenticator;
+import java.net.CookieManager;
+import java.net.CookiePolicy;
+import java.net.HttpURLConnection;
+import java.net.PasswordAuthentication;
+import java.net.ProxySelector;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+import org.junit.jupiter.api.Test;
+
+public class HttpClientUnitTest {
+
+    @Test
+    public void shouldReturnSampleDataContentWhenConnectViaSystemProxy() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofString("Sample body"))
+            .build();
+      
+        
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .proxy(ProxySelector.getDefault())
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+        
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample body"));
+    }
+
+    @Test
+    public void shouldNotFollowRedirectWhenSetToDefaultNever() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_MOVED_PERM));
+        assertTrue(response.headers().map().get("location").stream().anyMatch("https://stackoverflow.com/"::equals));
+    }
+
+    @Test
+    public void shouldFollowRedirectWhenSetToAlways() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.ALWAYS)
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.request()
+            .uri()
+            .toString(), equalTo("https://stackoverflow.com/"));
+    }
+
+    @Test
+    public void shouldReturnOKStatusForAuthenticatedAccess() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/basic-auth"))
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .authenticator(new Authenticator() {
+                @Override
+                protected PasswordAuthentication getPasswordAuthentication() {
+                    return new PasswordAuthentication("postman", "password".toCharArray());
+                }
+            })
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldSendRequestAsync() throws URISyntaxException, InterruptedException, ExecutionException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofString("Sample body"))
+            .build();
+        CompletableFuture<HttpResponse<String>> response = HttpClient.newBuilder()
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldUseJustTwoThreadWhenProcessingSendAsyncRequest() throws URISyntaxException, InterruptedException, ExecutionException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+
+        CompletableFuture<HttpResponse<String>> response1 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString());
+
+        CompletableFuture<HttpResponse<String>> response2 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString());
+
+        CompletableFuture<HttpResponse<String>> response3 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandlers.ofString());
+
+        CompletableFuture.allOf(response1, response2, response3)
+            .join();
+
+        assertThat(response1.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response2.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response3.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldNotStoreCookieWhenPolicyAcceptNone() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .cookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_NONE))
+            .build();
+
+        httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertTrue(httpClient.cookieHandler()
+            .isPresent());
+    }
+
+    @Test
+    public void shouldStoreCookieWhenPolicyAcceptAll() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .cookieHandler(new CookieManager(null, CookiePolicy.ACCEPT_ALL))
+            .build();
+
+        httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertTrue(httpClient.cookieHandler()
+            .isPresent());
+    }
+
+    @Test
+    public void shouldProcessMultipleRequestViaStream() throws URISyntaxException, ExecutionException, InterruptedException {
+        List<URI> targets = Arrays.asList(new URI("https://postman-echo.com/get?foo1=bar1"), new URI("https://postman-echo.com/get?foo2=bar2"));
+
+        HttpClient client = HttpClient.newHttpClient();
+
+        List<CompletableFuture<String>> futures = targets.stream()
+            .map(target -> client.sendAsync(HttpRequest.newBuilder(target)
+                .GET()
+                .build(), HttpResponse.BodyHandlers.ofString())
+                .thenApply(response -> response.body()))
+            .collect(Collectors.toList());
+
+        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
+            .join();
+
+        if (futures.get(0)
+            .get()
+            .contains("foo1")) {
+            assertThat(futures.get(0)
+                .get(), containsString("bar1"));
+            assertThat(futures.get(1)
+                .get(), containsString("bar2"));
+        } else {
+            assertThat(futures.get(1)
+                .get(), containsString("bar2"));
+            assertThat(futures.get(1)
+                .get(), containsString("bar1"));
+        }
+
+    }
+    
+    @Test
+    public void completeExceptionallyExample() {
+        CompletableFuture<String> cf = CompletableFuture.completedFuture("message").thenApplyAsync(String::toUpperCase,
+                CompletableFuture.delayedExecutor(1, TimeUnit.SECONDS));
+        CompletableFuture<String> exceptionHandler = cf.handle((s, th) -> { return (th != null) ? "message upon cancel" : ""; });
+        cf.completeExceptionally(new RuntimeException("completed exceptionally"));
+        assertTrue("Was not completed exceptionally", cf.isCompletedExceptionally());
+        try {
+            cf.join();
+            fail("Should have thrown an exception");
+        } catch (CompletionException ex) { // just for testing
+            assertEquals("completed exceptionally", ex.getCause().getMessage());
+        }
+
+        assertEquals("message upon cancel", exceptionHandler.join());
+    }
+
+}
@@ -0,0 +1,174 @@
+package com.baeldung.java11.httpclient.test;
+
+import static java.time.temporal.ChronoUnit.SECONDS;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.file.Paths;
+import java.security.NoSuchAlgorithmException;
+import java.time.Duration;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class HttpRequestUnitTest {
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldUseHttp2WhenWebsiteUsesHttp2() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.version(), equalTo(HttpClient.Version.HTTP_2));
+    }
+
+    /*
+    * This test will fail as soon as the given URL returns a HTTP 2 response.
+    * Therefore, let's leave it ignored.
+    * */
+    @Test
+    @Ignore
+    public void shouldFallbackToHttp1_1WhenWebsiteDoesNotUseHttp2() throws IOException, InterruptedException, URISyntaxException, NoSuchAlgorithmException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.version(), equalTo(HttpClient.Version.HTTP_1_1));
+    }
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequestWithDummyHeaders() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .headers("key1", "value1", "key2", "value2")
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequestTimeoutSet() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .timeout(Duration.of(10, SECONDS))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnNoContentWhenPostWithNoBody() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .POST(HttpRequest.BodyPublishers.noBody())
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithBodyText() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofString("Sample request body"))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithInputStream() throws IOException, InterruptedException, URISyntaxException {
+        byte[] sampleData = "Sample request body".getBytes();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofInputStream(() -> new ByteArrayInputStream(sampleData)))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithByteArrayProcessorStream() throws IOException, InterruptedException, URISyntaxException {
+        byte[] sampleData = "Sample request body".getBytes();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofByteArray(sampleData))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithFileProcessorStream() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyPublishers.ofFile(Paths.get("src/test/resources/sample.txt")))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample file content"));
+    }
+
+}
@@ -0,0 +1,54 @@
+package com.baeldung.java11.httpclient.test;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+
+import org.junit.Test;
+
+public class HttpResponseUnitTest {
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.NORMAL)
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertNotNull(response.body());
+    }
+
+    @Test
+    public void shouldResponseURIDifferentThanRequestUIRWhenRedirect() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.NORMAL)
+            .build()
+            .send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertThat(request.uri()
+            .toString(), equalTo("http://stackoverflow.com"));
+        assertThat(response.uri()
+            .toString(), equalTo("https://stackoverflow.com/"));
+    }
+
+}
@@ -0,0 +1,23 @@
+package com.baeldung.optional;
+
+import org.junit.Test;
+
+import java.util.Optional;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit tests for {@link Optional} in Java 11.
+ */
+public class OptionalUnitTest {
+
+    @Test
+    public void givenAnEmptyOptional_isEmpty_thenBehavesAsExpected() {
+        Optional<String> opt = Optional.of("Baeldung");
+        assertFalse(opt.isEmpty());
+
+        opt = Optional.ofNullable(null);
+        assertTrue(opt.isEmpty());
+    }
+}
@@ -0,0 +1,29 @@
+package com.baeldung.patternreuse;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class PatternJava11UnitTest {
+
+    @Test
+    public void givenPreCompiledPattern_whenCallAsMatchPredicate_thenReturnMatchPredicateToMatchesPattern() {
+        List<String> namesToValidate = Arrays.asList("Fabio Silva", "Fabio Luis Silva");
+        Pattern firstLastNamePreCompiledPattern = Pattern.compile("[a-zA-Z]{3,} [a-zA-Z]{3,}");
+
+        Predicate<String> patternAsMatchPredicate = firstLastNamePreCompiledPattern.asMatchPredicate();
+        List<String> validatedNames = namesToValidate.stream()
+                .filter(patternAsMatchPredicate)
+                .collect(Collectors.toList());
+
+        assertTrue(validatedNames.contains("Fabio Silva"));
+        assertFalse(validatedNames.contains("Fabio Luis Silva"));
+    }
+}
@@ -0,0 +1,61 @@
+package com.baeldung.predicate.not;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static java.util.function.Predicate.not;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class PersonUnitTest {
+    private List<Person> people;
+
+    @BeforeEach
+    void preparePeople() {
+        people = Arrays.asList(
+          new Person(1),
+          new Person(18),
+          new Person(2)
+        );
+    }
+
+    @Test
+    void givenPeople_whenFilterIsAdult_thenOneResult() {
+        List<Person> adults = people.stream()
+          .filter(Person::isAdult)
+          .collect(Collectors.toList());
+
+        assertThat(adults).size().isEqualTo(1);
+    }
+
+    @Test
+    void givenPeople_whenFilterIsAdultNegated_thenTwoResults() {
+        List<Person> nonAdults = people.stream()
+          .filter(person -> !person.isAdult())
+          .collect(Collectors.toList());
+
+        assertThat(nonAdults).size().isEqualTo(2);
+    }
+
+    @Test
+    void givenPeople_whenFilterIsNotAdult_thenTwoResults() {
+        List<Person> nonAdults = people.stream()
+          .filter(Person::isNotAdult)
+          .collect(Collectors.toList());
+
+        assertThat(nonAdults).size().isEqualTo(2);
+    }
+
+    @Test
+    void givenPeople_whenFilterNotIsAdult_thenTwoResults() {
+        List<Person> nonAdults = people.stream()
+          .filter(not(Person::isAdult))
+          .collect(Collectors.toList());
+
+        assertThat(nonAdults).size().isEqualTo(2);
+    }
+}
@@ -0,0 +1,5 @@
+## Relevant Articles:
+
+- [String API Updates in Java 12](https://www.baeldung.com/java12-string-api)
+- [New Features in Java 12](https://www.baeldung.com/java-12-new-features)
+- [Compare the Content of Two Files in Java](https://www.baeldung.com/java-compare-files)
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-12</artifactId>
+    <packaging>jar</packaging>
+    <name>core-java-12</name>
+
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>${commons-io.version}</version>
+        </dependency>
+    </dependencies>
+
+</project>
@@ -0,0 +1,88 @@
+package com.baeldung.file.content.comparison;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public class CompareFileContents {
+
+    public static long filesCompareByByte(Path path1, Path path2) throws IOException {
+
+        if (path1.getFileSystem()
+            .provider()
+            .isSameFile(path1, path2)) {
+            return -1;
+        }
+
+        try (BufferedInputStream fis1 = new BufferedInputStream(new FileInputStream(path1.toFile())); 
+            BufferedInputStream fis2 = new BufferedInputStream(new FileInputStream(path2.toFile()))) {
+            int ch = 0;
+            long pos = 1;
+            while ((ch = fis1.read()) != -1) {
+                if (ch != fis2.read()) {
+                    return pos;
+                }
+                pos++;
+            }
+            if (fis2.read() == -1) {
+                return -1;
+            } else {
+                return pos;
+            }
+        }
+    }
+
+    public static long filesCompareByLine(Path path1, Path path2) throws IOException {
+
+        if (path1.getFileSystem()
+            .provider()
+            .isSameFile(path1, path2)) {
+            return -1;
+        }
+
+        try (BufferedReader bf1 = Files.newBufferedReader(path1); 
+            BufferedReader bf2 = Files.newBufferedReader(path2)) {
+            
+            long lineNumber = 1;
+            String line1 = "", line2 = "";
+            while ((line1 = bf1.readLine()) != null) {
+                line2 = bf2.readLine();
+                if (line2 == null || !line1.equals(line2)) {
+                    return lineNumber;
+                }
+                lineNumber++;
+            }
+            if (bf2.readLine() == null) {
+                return -1;
+            } else {
+                return lineNumber;
+            }
+        }
+    }
+
+    public static boolean compareByMemoryMappedFiles(Path path1, Path path2) throws IOException {
+    
+        try (RandomAccessFile randomAccessFile1 = new RandomAccessFile(path1.toFile(), "r"); 
+            RandomAccessFile randomAccessFile2 = new RandomAccessFile(path2.toFile(), "r")) {
+            
+            FileChannel ch1 = randomAccessFile1.getChannel();
+            FileChannel ch2 = randomAccessFile2.getChannel();
+            if (ch1.size() != ch2.size()) {
+    
+                return false;
+            }
+            long size = ch1.size();
+            MappedByteBuffer m1 = ch1.map(FileChannel.MapMode.READ_ONLY, 0L, size);
+            MappedByteBuffer m2 = ch2.map(FileChannel.MapMode.READ_ONLY, 0L, size);
+    
+            return m1.equals(m2);
+        }
+    }
+}
@@ -0,0 +1,71 @@
+package com.baeldung.collectors;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+import org.junit.Test;
+
+import static java.util.stream.Collectors.maxBy;
+import static java.util.stream.Collectors.minBy;
+import static java.util.stream.Collectors.teeing;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for collectors additions in Java 12.
+ */
+public class CollectorsUnitTest {
+
+    @Test
+    public void whenTeeing_ItShouldCombineTheResultsAsExpected() {
+        List<Integer> numbers = Arrays.asList(42, 4, 2, 24);
+        Range range = numbers.stream()
+            .collect(teeing(minBy(Integer::compareTo), maxBy(Integer::compareTo), (min, max) -> new Range(min.orElse(null), max.orElse(null))));
+
+        assertThat(range).isEqualTo(new Range(2, 42));
+    }
+
+    /**
+     * Represents a closed range of numbers between {@link #min} and
+     * {@link #max}, both inclusive.
+     */
+    private static class Range {
+
+        private final Integer min;
+
+        private final Integer max;
+
+        Range(Integer min, Integer max) {
+            this.min = min;
+            this.max = max;
+        }
+
+        Integer getMin() {
+            return min;
+        }
+
+        Integer getMax() {
+            return max;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            Range range = (Range) o;
+            return Objects.equals(getMin(), range.getMin()) && Objects.equals(getMax(), range.getMax());
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(getMin(), getMax());
+        }
+
+        @Override
+        public String toString() {
+            return "Range{" + "min=" + min + ", max=" + max + '}';
+        }
+    }
+}
@@ -0,0 +1,88 @@
+package com.baeldung.file.content.comparison;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.Reader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.apache.commons.io.IOUtils;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+public class CampareFileContentsApacheIOUnitTest {
+
+    public static Path path1 = null;
+    public static Path path2 = null;
+
+    @BeforeAll
+    public static void setup() throws IOException {
+
+        path1 = Files.createTempFile("file1Test", ".txt");
+        path2 = Files.createTempFile("file2Test", ".txt");
+    }
+
+    @Test
+    public void whenFilesIdentical_thenReturnTrue() throws IOException {
+
+        InputStream inputStream1 = new FileInputStream(path1.toFile());
+        InputStream inputStream2 = new FileInputStream(path2.toFile());
+
+        Files.writeString(path1, "testing line 1" + System.lineSeparator() + "line 2");
+        Files.writeString(path2, "testing line 1" + System.lineSeparator() + "line 2");
+
+        assertTrue(IOUtils.contentEquals(inputStream1, inputStream2));
+    }
+
+    @Test
+    public void whenFilesDifferent_thenReturnFalse() throws IOException {
+
+        InputStream inputStream1 = new FileInputStream(path1.toFile());
+        InputStream inputStream2 = new FileInputStream(path2.toFile());
+
+        Files.writeString(path1, "testing line " + System.lineSeparator() + "line 2");
+        Files.writeString(path2, "testing line 1" + System.lineSeparator() + "line 2");
+
+        assertFalse(IOUtils.contentEquals(inputStream1, inputStream2));
+    }
+
+    @Test
+    public void whenFilesIdenticalIgnoreEOF_thenReturnTrue() throws IOException {
+
+        Files.writeString(path1, "testing line 1 \n line 2");
+        Files.writeString(path2, "testing line 1 \r\n line 2");
+
+        Reader reader1 = new BufferedReader(new FileReader(path1.toFile()));
+        Reader reader2 = new BufferedReader(new FileReader(path2.toFile()));
+
+        assertTrue(IOUtils.contentEqualsIgnoreEOL(reader1, reader2));
+    }
+
+    @Test
+    public void whenFilesNotIdenticalIgnoreEOF_thenReturnFalse() throws IOException {
+
+        Files.writeString(path1, "testing line  \n line 2");
+        Files.writeString(path2, "testing line 1 \r\n line 2");
+
+        Reader reader1 = new BufferedReader(new FileReader(path1.toFile()));
+        Reader reader2 = new BufferedReader(new FileReader(path2.toFile()));
+
+        assertFalse(IOUtils.contentEqualsIgnoreEOL(reader1, reader2));
+    }
+
+    @AfterAll
+    public static void shutDown() {
+
+        path1.toFile()
+            .deleteOnExit();
+        path2.toFile()
+            .deleteOnExit();
+    }
+}
@@ -0,0 +1,42 @@
+package com.baeldung.file.content.comparison;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+public class CompareByMemoryMappedFilesUnitTest {
+
+    public static Path path1 = null;
+    public static Path path2 = null;
+
+    @BeforeAll
+    public static void setup() throws IOException {
+
+        path1 = Files.createTempFile("file1Test", ".txt");
+        path2 = Files.createTempFile("file2Test", ".txt");
+    }
+
+    @Test
+    public void whenFilesIdentical_thenReturnTrue() throws IOException {
+
+        Files.writeString(path1, "testing line 1" + System.lineSeparator() + "line 2");
+        Files.writeString(path2, "testing line 1" + System.lineSeparator() + "line 2");
+
+        assertTrue(CompareFileContents.compareByMemoryMappedFiles(path1, path2));
+    }
+
+    @Test
+    public void whenFilesDifferent_thenReturnFalse() throws IOException {
+
+        Files.writeString(path1, "testing line " + System.lineSeparator() + "line 2");
+        Files.writeString(path2, "testing line 1" + System.lineSeparator() + "line 2");
+
+        assertFalse(CompareFileContents.compareByMemoryMappedFiles(path1, path2));
+    }
+}
@@ -0,0 +1,96 @@
+package com.baeldung.file.content.comparison;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+public class CompareFileContentsByBytesUnitTest {
+    
+    public static Path path1 = null;
+    public static Path path2 = null;
+    
+   @BeforeAll
+    public static void setup()  throws IOException {
+       
+       path1 = Files.createTempFile("file1Test", ".txt");
+       path2 = Files.createTempFile("file2Test", ".txt");
+    }
+
+    @Test
+    public void whenFirstFileShorter_thenPositionInSecondFile() throws IOException {
+        
+        Files.writeString(path1, "testing");
+        Files.writeString(path2, "testing1");
+
+        assertEquals(8, CompareFileContents.filesCompareByByte(path1, path2));
+    }
+    
+    @Test
+    public void whenSecondFileShorter_thenPositionInFirstFile() throws IOException {
+        
+        Files.writeString(path1, "testing1");
+        Files.writeString(path2, "testing");
+
+        assertEquals(8, CompareFileContents.filesCompareByByte(path1, path2));
+
+    }
+
+    @Test
+    public void whenFilesIdentical_thenSuccess() throws IOException {
+        
+        Files.writeString(path1, "testing");
+        Files.writeString(path2, "testing");
+
+        assertEquals(-1, CompareFileContents.filesCompareByByte(path1, path2));
+
+    }
+
+    @Test
+    public void whenFilesDifferent_thenPosition() throws IOException {
+        
+        Files.writeString(path1, "tesXing");
+        Files.writeString(path2, "testing");
+
+        assertEquals(4, CompareFileContents.filesCompareByByte(path1, path2));
+    }
+
+    @Test
+    public void whenBothFilesEmpty_thenEqual() throws IOException {
+        
+        Files.writeString(path1, "");
+        Files.writeString(path2, "");
+
+        assertEquals(-1, CompareFileContents.filesCompareByByte(path1, path2));
+    }
+
+    @Test
+    public void whenFirstEmpty_thenPositionFirst() throws IOException {
+        
+        Files.writeString(path1, "");
+        Files.writeString(path2, "test");
+
+        assertEquals(1, CompareFileContents.filesCompareByByte(path1, path2));
+    }
+
+    @Test
+    public void whenSecondEmpty_thenPositionFirst() throws IOException {
+        
+        Files.writeString(path1, "test");
+        Files.writeString(path2, "");
+
+        assertEquals(1, CompareFileContents.filesCompareByByte(path1, path2));
+    }
+
+    @AfterAll
+    public static void shutDown() {
+        
+        path1.toFile().deleteOnExit();
+        path2.toFile().deleteOnExit();
+    }
+}
@@ -0,0 +1,94 @@
+package com.baeldung.file.content.comparison;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+public class CompareFileContentsByLinesUnitTest {
+
+    public static Path path1 = null;
+    public static Path path2 = null;
+    
+   @BeforeAll
+    public static void setup()  throws IOException {
+       
+       path1 = Files.createTempFile("file1Test", ".txt");
+       path2 = Files.createTempFile("file2Test", ".txt");
+    }
+
+   @Test
+   public void whenFirstFileShorter_thenLineNumbersFirstFile() throws IOException {
+       
+       Files.writeString(path1, "testing line 1");
+       Files.writeString(path2, "testing1 line 1" + System.lineSeparator() + "line 2");
+
+       assertEquals(1, CompareFileContents.filesCompareByLine(path1, path2));
+   }
+   
+   @Test
+   public void whenSecondFileShorter_thenLineNumbersSecondFile() throws IOException {
+       
+       Files.writeString(path1, "testing1 line 1" + System.lineSeparator() + "line 2");
+       Files.writeString(path2, "testing line 1");
+
+       assertEquals(1, CompareFileContents.filesCompareByLine(path1, path2));
+   }
+   
+   @Test
+   public void whenFileIdentical_thenLineSuccess() throws IOException {
+       
+       Files.writeString(path1, "testing1 line 1" + System.lineSeparator() + "line 2");
+       Files.writeString(path2, "testing1 line 1" + System.lineSeparator() + "line 2");
+
+       assertEquals(-1, CompareFileContents.filesCompareByLine(path1, path2));
+   }
+   
+   @Test
+   public void whenFilesDifferent_thenLineNumber() throws IOException {
+       
+       Files.writeString(path1, "testing1 line 1" + System.lineSeparator() + "line 2");
+       Files.writeString(path2, "testing1 line 1" + System.lineSeparator() + "linX 2");
+
+       assertEquals(2, CompareFileContents.filesCompareByLine(path1, path2));
+   }
+ 
+   @Test
+   public void whenBothFilesEmpty_thenEqual() throws IOException {
+       
+       Files.writeString(path1, "");
+       Files.writeString(path2, "");
+
+       assertEquals(-1, CompareFileContents.filesCompareByByte(path1, path2));
+   }
+
+   @Test
+   public void whenFirstEmpty_thenPositionFirst() throws IOException {
+       
+       Files.writeString(path1, "");
+       Files.writeString(path2, "testing1 line 1" + System.lineSeparator() + "line 2");
+
+       assertEquals(1, CompareFileContents.filesCompareByByte(path1, path2));
+   }
+
+   @Test
+   public void whenSecondEmpty_thenPositionFirst() throws IOException {
+       
+       Files.writeString(path1, "testing1 line 1" + System.lineSeparator() + "line 2");
+       Files.writeString(path2, "");
+
+       assertEquals(1, CompareFileContents.filesCompareByByte(path1, path2));
+   }
+
+    @AfterAll
+    public static void shutDown() {
+        
+        path1.toFile().deleteOnExit();
+        path2.toFile().deleteOnExit();
+    }
+}
@@ -0,0 +1,21 @@
+package com.baeldung.newfeatures;
+
+import org.junit.jupiter.api.Test;
+
+import java.text.NumberFormat;
+import java.util.Locale;
+
+import static org.junit.Assert.assertEquals;
+
+public class CompactNumbersUnitTest {
+
+    @Test
+    public void givenNumber_thenCompactValues() {
+        NumberFormat likesShort = NumberFormat.getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.SHORT);
+        likesShort.setMaximumFractionDigits(2);
+        assertEquals("2.59K", likesShort.format(2592));
+        NumberFormat likesLong = NumberFormat.getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.LONG);
+        likesLong.setMaximumFractionDigits(2);
+        assertEquals("2.59 thousand", likesLong.format(2592));
+    }
+}
@@ -0,0 +1,32 @@
+package com.baeldung.newfeatures;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.Assert.assertEquals;
+
+public class FileMismatchUnitTest {
+
+    @Test
+    public void givenIdenticalFiles_thenShouldNotFindMismatch() throws IOException {
+        Path filePath1 = Files.createTempFile("file1", ".txt");
+        Path filePath2 = Files.createTempFile("file2", ".txt");
+        Files.writeString(filePath1, "Java 12 Article");
+        Files.writeString(filePath2, "Java 12 Article");
+        long mismatch = Files.mismatch(filePath1, filePath2);
+        assertEquals(-1, mismatch);
+    }
+
+    @Test
+    public void givenDifferentFiles_thenShouldFindMismatch() throws IOException {
+        Path filePath3 = Files.createTempFile("file3", ".txt");
+        Path filePath4 = Files.createTempFile("file4", ".txt");
+        Files.writeString(filePath3, "Java 12 Article");
+        Files.writeString(filePath4, "Java 12 Tutorial");
+        long mismatch = Files.mismatch(filePath3, filePath4);
+        assertEquals(8, mismatch);
+    }
+}
@@ -0,0 +1,15 @@
+package com.baeldung.newfeatures;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringUnitTest {
+
+    @Test
+    public void givenString_thenRevertValue() {
+        String text = "Baeldung";
+        String transformed = text.transform(value -> new StringBuilder(value).reverse().toString());
+        assertEquals("gnudleaB", transformed);
+    }
+}
@@ -0,0 +1,18 @@
+package com.baeldung.newfeatures;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+
+public class TeeingCollectorUnitTest {
+
+    @Test
+    public void givenSetOfNumbers_thenCalculateAverage() {
+        double mean = Stream.of(1, 2, 3, 4, 5)
+          .collect(Collectors.teeing(Collectors.summingDouble(i -> i), Collectors.counting(), (sum, count) -> sum / count));
+        assertEquals(3.0, mean, 0);
+    }
+}
@@ -0,0 +1,43 @@
+package com.baeldung.string;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class StringAPIUnitTest {
+
+    @Test
+    public void whenPositiveArgument_thenReturnIndentedString() {
+        String multilineStr = "This is\na multiline\nstring.";
+        String outputStr = "   This is\n   a multiline\n   string.\n";
+
+        String postIndent = multilineStr.indent(3);
+
+        assertThat(postIndent, equalTo(outputStr));
+    }
+
+    @Test
+    public void whenNegativeArgument_thenReturnReducedIndentedString() {
+        String multilineStr = "   This is\n   a multiline\n   string.";
+        String outputStr = " This is\n a multiline\n string.\n";
+
+        String postIndent = multilineStr.indent(-2);
+
+        assertThat(postIndent, equalTo(outputStr));
+    }
+
+    @Test
+    public void whenTransformUsingLamda_thenReturnTransformedString() {
+        String result = "hello".transform(input -> input + " world!");
+
+        assertThat(result, equalTo("hello world!"));
+    }
+
+    @Test
+    public void whenTransformUsingParseInt_thenReturnInt() {
+        int result = "42".transform(Integer::parseInt);
+
+        assertThat(result, equalTo(42));
+    }
+}
@@ -0,0 +1,24 @@
+package com.baeldung.switchExpression;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SwitchUnitTest {
+
+    @Test
+    public void switchJava12(){
+
+        var month = Month.AUG;
+
+        var value = switch(month){
+            case JAN,JUN, JUL -> 3;
+            case FEB,SEP, OCT, NOV, DEC -> 1;
+            case MAR,MAY, APR, AUG -> 2;
+        };
+
+        Assert.assertEquals(value, 2);
+    }
+
+
+    enum Month {JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC}
+}
--- a/Show More
+++ b/Show More