Merge branch 'master' of https://github.com/eugenp/tutorials into BAEL-10982

core-groovy/src/main/groovy/com/baeldung/Person.groovy

@@ -0,0 +1,37 @@
+package com.baeldung
+
+class Person {
+    private String firstname
+    private String lastname
+    private Integer age
+
+    Person(String firstname, String lastname, Integer age) {
+        this.firstname = firstname
+        this.lastname = lastname
+        this.age = age
+    }
+
+    String getFirstname() {
+        return firstname
+    }
+
+    void setFirstname(String firstname) {
+        this.firstname = firstname
+    }
+
+    String getLastname() {
+        return lastname
+    }
+
+    void setLastname(String lastname) {
+        this.lastname = lastname
+    }
+
+    Integer getAge() {
+        return age
+    }
+
+    void setAge(Integer age) {
+        this.age = age
+    }
+}

core-groovy/src/test/groovy/com/baeldung/lists/ListTest.groovy

@@ -129,13 +129,13 @@ class ListTest{
         assertTrue(filterList.findAll{it > 3} == [4, 5, 6, 76])
 
         assertTrue(filterList.findAll{ it instanceof Number} == [2, 1, 3, 4, 5, 6, 76])
-        
+
         assertTrue(filterList.grep( Number )== [2, 1, 3, 4, 5, 6, 76])
-        
+
         assertTrue(filterList.grep{ it> 6 }== [76])
 
         def conditionList = [2, 1, 3, 4, 5, 6, 76]
-        
+
         assertFalse(conditionList.every{ it < 6})
 
         assertTrue(conditionList.any{ it%2 == 0})
@@ -165,7 +165,7 @@ class ListTest{
 
         def strList = ["na", "ppp", "as"]
         assertTrue(strList.max() == "ppp")
-        
+
         Comparator minc = {a,b -> a == b? 0: a < b? -1 : 1}
         def numberList = [3, 2, 0, 7]
         assertTrue(numberList.min(minc) == 0)

core-groovy/src/test/groovy/com/baeldung/lists/ListUnitTest.groovy

@@ -0,0 +1,58 @@
+package com.baeldung.lists
+
+import com.baeldung.Person
+import org.junit.Test
+
+import static org.junit.Assert.*
+
+class ListUnitTest {
+
+    private final personList = [
+      new Person("Regina", "Fitzpatrick", 25),
+      new Person("Abagail", "Ballard", 26),
+      new Person("Lucian", "Walter", 30),
+    ]
+
+    @Test
+    void whenListContainsElement_thenCheckReturnsTrue() {
+        def list = ['a', 'b', 'c']
+
+        assertTrue(list.indexOf('a') > -1)
+        assertTrue(list.contains('a'))
+    }
+
+    @Test
+    void whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue() {
+        def list = ['a', 'b', 'c']
+
+        assertTrue('a' in list)
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList() {
+        assertTrue(personList.stream().anyMatch {it.age > 20})
+        assertFalse(personList.stream().allMatch {it.age < 30})
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList() {
+        assertTrue(personList.any {it.age > 20})
+        assertFalse(personList.every {it.age < 30})
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingStreamFind_thenShouldReturnMatchingElements() {
+        assertTrue(personList.stream().filter {it.age > 20}.findAny().isPresent())
+        assertFalse(personList.stream().filter {it.age > 30}.findAny().isPresent())
+        assertTrue(personList.stream().filter {it.age > 20}.findAll().size() == 3)
+        assertTrue(personList.stream().filter {it.age > 30}.findAll().isEmpty())
+    }
+
+    @Test
+    void givenListOfPerson_whenUsingCollectionFind_thenShouldReturnMatchingElements() {
+        assertNotNull(personList.find {it.age > 20})
+        assertNull(personList.find {it.age > 30})
+        assertTrue(personList.findAll {it.age > 20}.size() == 3)
+        assertTrue(personList.findAll {it.age > 30}.isEmpty())
+    }
+}

core-groovy/src/test/groovy/com/baeldung/map/MapUnitTest.groovy

@@ -1,10 +1,18 @@
 package com.baeldung.map
 
-import static org.junit.Assert.*
+import com.baeldung.Person
 import org.junit.Test
 
+import static org.junit.Assert.*
+
 class MapUnitTest {
 
+    private final personMap = [
+      Regina : new Person("Regina", "Fitzpatrick", 25),
+      Abagail: new Person("Abagail", "Ballard", 26),
+      Lucian : new Person("Lucian", "Walter", 30)
+    ]
+
     @Test
     void whenUsingEach_thenMapIsIterated() {
         def map = [
@@ -63,7 +71,7 @@ class MapUnitTest {
             'FF6347' : 'Tomato',
             'FF4500' : 'Orange Red'
         ]
-        
+
         map.eachWithIndex { key, val, index ->
             def indent = ((index == 0 || index % 2 == 0) ? "   " : "")
             println "$indent Hex Code: $key = Color Name: $val"
@@ -82,4 +90,65 @@ class MapUnitTest {
             println "Hex Code: $entry.key = Color Name: $entry.value"
         }
     }
+
+    @Test
+    void whenMapContainsKeyElement_thenCheckReturnsTrue() {
+        def map = [a: 'd', b: 'e', c: 'f']
+
+        assertTrue(map.containsKey('a'))
+        assertFalse(map.containsKey('e'))
+        assertTrue(map.containsValue('e'))
+    }
+
+    @Test
+    void whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue() {
+        def map = [a: 'd', b: 'e', c: 'f']
+
+        assertTrue('a' in map)
+        assertFalse('f' in map)
+    }
+
+    @Test
+    void whenMapContainsFalseBooleanValues_thenCheckReturnsFalse() {
+        def map = [a: true, b: false, c: null]
+
+        assertTrue(map.containsKey('b'))
+        assertTrue('a' in map)
+        assertFalse('b' in map)
+        assertFalse('c' in map)
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingStreamMatching_thenShouldEvaluateMap() {
+        assertTrue(personMap.keySet().stream().anyMatch {it == "Regina"})
+        assertFalse(personMap.keySet().stream().allMatch {it == "Albert"})
+        assertFalse(personMap.values().stream().allMatch {it.age < 30})
+        assertTrue(personMap.entrySet().stream().anyMatch {it.key == "Abagail" && it.value.lastname == "Ballard"})
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingCollectionMatching_thenShouldEvaluateMap() {
+        assertTrue(personMap.keySet().any {it == "Regina"})
+        assertFalse(personMap.keySet().every {it == "Albert"})
+        assertFalse(personMap.values().every {it.age < 30})
+        assertTrue(personMap.any {firstname, person -> firstname == "Abagail" && person.lastname == "Ballard"})
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingCollectionFind_thenShouldReturnElements() {
+        assertNotNull(personMap.find {it.key == "Abagail" && it.value.lastname == "Ballard"})
+        assertTrue(personMap.findAll {it.value.age > 20}.size() == 3)
+    }
+
+    @Test
+    void givenMapOfPerson_whenUsingStreamFind_thenShouldReturnElements() {
+        assertTrue(
+          personMap.entrySet().stream()
+            .filter {it.key == "Abagail" && it.value.lastname == "Ballard"}
+            .findAny().isPresent())
+        assertTrue(
+          personMap.entrySet().stream()
+            .filter {it.value.age > 20}
+            .findAll().size() == 3)
+    }
 }

core-groovy/src/test/groovy/com/baeldung/set/SetUnitTest.groovy

@@ -0,0 +1,16 @@
+package com.baeldung.set
+
+import org.junit.Test
+
+import static org.junit.Assert.assertTrue
+
+class SetUnitTest {
+
+    @Test
+    void whenSetContainsElement_thenCheckReturnsTrue() {
+        def set = ['a', 'b', 'c'] as Set
+
+        assertTrue(set.contains('a'))
+        assertTrue('a' in set)
+    }
+}

core-java-11/src/modules/jlinkModule/com/baeldung/jlink/HelloWorld.java

@@ -0,0 +1,12 @@
+package com.baeldung.jlink;
+
+import java.util.logging.Logger;
+
+public class HelloWorld {
+
+    private static final Logger LOG = Logger.getLogger(HelloWorld.class.getName());
+
+    public static void main(String[] args) {
+        LOG.info("Hello World!");
+    }
+}

core-java-11/src/modules/jlinkModule/module-info.java

@@ -0,0 +1,3 @@
+module jlinkModule {
+    requires java.logging;
+}

core-java-12/pom.xml

@@ -0,0 +1,48 @@
+<?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>
+	<groupId>com.baeldung</groupId>
+	<artifactId>core-java-12</artifactId>
+	<version>0.1.0-SNAPSHOT</version>
+	<name>core-java-12</name>
+	<packaging>jar</packaging>
+	<url>http://maven.apache.org</url>
+
+	<parent>
+		<groupId>com.baeldung</groupId>
+		<artifactId>parent-modules</artifactId>
+		<version>1.0.0-SNAPSHOT</version>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>org.assertj</groupId>
+			<artifactId>assertj-core</artifactId>
+			<version>${assertj.version}</version>
+			<scope>test</scope>
+		</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>12</maven.compiler.source.version>
+		<maven.compiler.target.version>12</maven.compiler.target.version>
+		<assertj.version>3.6.1</assertj.version>
+	</properties>
+
+</project>

core-java-12/src/test/java/com/baeldung/collectors/CollectorsUnitTest.java

@@ -0,0 +1,77 @@
+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 +
+					'}';
+		}
+	}
+}

core-java-8/src/test/java/com/baeldung/java8/Java8SortUnitTest.java

@@ -124,11 +124,44 @@ public class Java8SortUnitTest {
 
     @Test
     public final void givenStreamCustomOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
-        
         final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
         final Comparator<Human> nameComparator = (h1, h2) -> h1.getName().compareTo(h2.getName());
         
         final List<Human> sortedHumans = humans.stream().sorted(nameComparator).collect(Collectors.toList());
         Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12)));
     }
+
+    @Test
+    public final void givenStreamComparatorOrdering_whenSortingEntitiesByName_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        final List<Human> sortedHumans = humans.stream().sorted(Comparator.comparing(Human::getName)).collect(Collectors.toList());
+        Assert.assertThat(sortedHumans.get(0), equalTo(new Human("Jack", 12)));
+    }
+
+    @Test
+    public final void givenStreamNaturalOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<String> letters = Lists.newArrayList("B", "A", "C");
+
+        final List<String> reverseSortedLetters = letters.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedLetters.get(0), equalTo("C"));
+    }
+
+    @Test
+    public final void givenStreamCustomOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+        final Comparator<Human> reverseNameComparator = (h1, h2) -> h2.getName().compareTo(h1.getName());
+
+        final List<Human> reverseSortedHumans = humans.stream().sorted(reverseNameComparator).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
+    @Test
+    public final void givenStreamComparatorOrdering_whenSortingEntitiesByNameReversed_thenCorrectlySorted() {
+        final List<Human> humans = Lists.newArrayList(new Human("Sarah", 10), new Human("Jack", 12));
+
+        final List<Human> reverseSortedHumans = humans.stream().sorted(Comparator.comparing(Human::getName, Comparator.reverseOrder())).collect(Collectors.toList());
+        Assert.assertThat(reverseSortedHumans.get(0), equalTo(new Human("Sarah", 10)));
+    }
+
 }

core-java-networking/src/main/java/com/baeldung/socket/read/Client.java

@@ -0,0 +1,29 @@
+package com.baeldung.socket.read;
+
+import java.net.*;
+import java.nio.charset.StandardCharsets;
+import java.io.*; 
+
+public class Client {
+    
+    public void runClient(String ip, int port) {
+        try {
+            Socket socket = new Socket(ip, port);
+            System.out.println("Connected to server ...");
+            DataInputStream in = new DataInputStream(System.in);
+            DataOutputStream out = new DataOutputStream(socket.getOutputStream());
+            
+            char type = 's'; // s for string
+            int length = 29;
+            String data = "This is a string of length 29";
+            byte[] dataInBytes = data.getBytes(StandardCharsets.UTF_8);         
+            //Sending data in TLV format        
+            out.writeChar(type);
+            out.writeInt(length);
+            out.write(dataInBytes);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

core-java-networking/src/main/java/com/baeldung/socket/read/Server.java

@@ -0,0 +1,49 @@
+package com.baeldung.socket.read;
+
+import java.net.*;
+import java.nio.charset.StandardCharsets;
+import java.io.*; 
+
+public class Server {
+    
+    public void runServer(int port) {
+        //Start the server and wait for connection
+        try {
+            ServerSocket server = new ServerSocket(port);
+            System.out.println("Server Started. Waiting for connection ...");
+            Socket socket = server.accept();
+            System.out.println("Got connection from client.");
+            //Get input stream from socket variable and convert the same to DataInputStream
+            DataInputStream in = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
+            //Read type and length of data
+            char dataType = in.readChar();
+            int length = in.readInt();
+            System.out.println("Type : "+dataType);
+            System.out.println("Lenght :"+length);
+            if(dataType == 's') {
+                //Read String data in bytes
+                byte[] messageByte = new byte[length];
+                boolean end = false;
+                StringBuilder dataString = new StringBuilder(length);
+                int totalBytesRead = 0;
+                //We need to run while loop, to read all data in that stream
+                while(!end) {
+                    int currentBytesRead = in.read(messageByte);
+                    totalBytesRead = currentBytesRead + totalBytesRead;
+                    if(totalBytesRead <= length) {
+                        dataString.append(new String(messageByte,0,currentBytesRead,StandardCharsets.UTF_8));
+                    } else {
+                        dataString.append(new String(messageByte,0,length - totalBytesRead + currentBytesRead,StandardCharsets.UTF_8));
+                    }
+                    if(dataString.length()>=length) {
+                        end = true;
+                    }
+                }
+                System.out.println("Read "+length+" bytes of message from client. Message = "+dataString);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}

core-java-networking/src/test/java/com/baeldung/socket/read/SocketReadAllDataLiveTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.socket.read;
+
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+
+public class SocketReadAllDataLiveTest {
+    
+    @Test
+    public void givenServerAndClient_whenClientSendsAndServerReceivesData_thenCorrect() {
+        //Run server in new thread
+        Runnable runnable1 = () -> { runServer(); };
+        Thread thread1 = new Thread(runnable1);
+        thread1.start();
+        //Wait for 10 seconds 
+        try {
+            TimeUnit.SECONDS.sleep(10);
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        //Run client in a new thread
+        Runnable runnable2 = () -> { runClient(); };
+        Thread thread2 = new Thread(runnable2);
+        thread2.start();
+    }
+    
+    public static void runServer() {
+        //Run Server
+        Server server = new Server();
+        server.runServer(5555);
+    }
+    
+    public static void runClient() {
+        //Run Client
+        Client client = new Client();
+        client.runClient("127.0.0.1", 5555);
+    }
+}

core-kotlin-2/src/main/kotlin/com/baeldung/scope/ScopeFunctions.kt

@@ -0,0 +1,25 @@
+package com.baeldung.scope
+
+data class Student(var studentId: String = "", var name: String = "", var surname: String = "") {
+}
+
+data class Teacher(var teacherId: Int = 0, var name: String = "", var surname: String = "") {
+    fun setId(anId: Int): Teacher = apply { teacherId = anId }
+    fun setName(aName: String): Teacher = apply { name = aName }
+    fun setSurname(aSurname: String): Teacher = apply { surname = aSurname }
+}
+
+data class Headers(val headerInfo: String)
+
+data class Response(val headers: Headers)
+
+data class RestClient(val url: String) {
+    fun getResponse() = Response(Headers("some header info"))
+}
+
+data class BankAccount(val id: Int) {
+    fun checkAuthorization(username: String) = Unit
+    fun addPayee(payee: String) = Unit
+    fun makePayment(paymentDetails: String) = Unit
+
+}

core-kotlin-2/src/test/kotlin/com/baeldung/annotations/ValidationTest.kt

@@ -4,7 +4,7 @@ import org.junit.Test
 import kotlin.test.assertTrue
 import kotlin.test.assertFalse
 
-class ValidationUnitTest {
+class ValidationTest {
 
     @Test
     fun whenAmountIsOneAndNameIsAlice_thenTrue() {

core-kotlin-2/src/test/kotlin/com/baeldung/annotations/ValidationUnitTest.kt

@@ -1,42 +0,0 @@
-package com.baeldung.annotations
-
-import org.junit.jupiter.api.Assertions.assertTrue
-import org.junit.jupiter.api.Assertions.assertFalse
-import org.junit.jupiter.api.Test
-
-
-class ValidationUnitTest {
-
-    @Test
-    fun whenAmountIsOneAndNameIsAlice_thenTrue() {
-        assertTrue(Validator().isValid(Item(1f, "Alice")))
-    }
-
-    @Test
-    fun whenAmountIsOneAndNameIsBob_thenTrue() {
-        assertTrue(Validator().isValid(Item(1f, "Bob")))
-    }
-
-
-    @Test
-    fun whenAmountIsMinusOneAndNameIsAlice_thenFalse() {
-        assertFalse(Validator().isValid(Item(-1f, "Alice")))
-    }
-
-    @Test
-    fun whenAmountIsMinusOneAndNameIsBob_thenFalse() {
-        assertFalse(Validator().isValid(Item(-1f, "Bob")))
-    }
-
-    @Test
-    fun whenAmountIsOneAndNameIsTom_thenFalse() {
-        assertFalse(Validator().isValid(Item(1f, "Tom")))
-    }
-
-    @Test
-    fun whenAmountIsMinusOneAndNameIsTom_thenFalse() {
-        assertFalse(Validator().isValid(Item(-1f, "Tom")))
-    }
-
-
-}

core-kotlin-2/src/test/kotlin/com/baeldung/scope/ScopeFunctionsUnitTest.kt

@@ -0,0 +1,143 @@
+package com.baeldung.scope
+
+import org.junit.Test
+import kotlin.test.assertTrue
+
+
+class ScopeFunctionsUnitTest {
+
+    class Logger {
+
+        var called : Boolean = false
+
+        fun info(message: String) {
+            called = true
+        }
+
+        fun wasCalled() = called
+    }
+
+    @Test
+    fun shouldTransformWhenLetFunctionUsed() {
+        val stringBuider = StringBuilder()
+        val numberOfCharacters = stringBuider.let {
+            it.append("This is a transformation function.")
+            it.append("It takes a StringBuilder instance and returns the number of characters in the generated String")
+            it.length
+        }
+
+        assertTrue {
+            numberOfCharacters == 128
+        }
+    }
+
+    @Test
+    fun shouldHandleNullabilityWhenLetFunctionUsed() {
+
+        val message: String? = "hello there!"
+        val charactersInMessage = message?.let {
+            "At this point is safe to reference the variable. Let's print the message: $it"
+        } ?: "default value"
+
+        assertTrue {
+            charactersInMessage.equals("At this point is safe to reference the variable. Let's print the message: hello there!")
+        }
+
+        val aNullMessage = null
+        val thisIsNull = aNullMessage?.let {
+            "At this point it would be safe to reference the variable. But it will not really happen because it is null. Let's reference: $it"
+        } ?: "default value"
+
+        assertTrue {
+            thisIsNull.equals("default value")
+        }
+    }
+
+    @Test
+    fun shouldInitializeObjectWhenUsingApply() {
+        val aStudent = Student().apply {
+            studentId = "1234567"
+            name = "Mary"
+            surname = "Smith"
+        }
+
+        assertTrue {
+            aStudent.name.equals("Mary")
+        }
+    }
+
+    @Test
+    fun shouldAllowBuilderStyleObjectDesignWhenApplyUsedInClassMethods() {
+        val teacher = Teacher()
+            .setId(1000)
+            .setName("Martha")
+            .setSurname("Spector")
+
+        assertTrue {
+            teacher.surname.equals("Spector")
+        }
+    }
+
+    @Test
+    fun shouldAllowSideEffectWhenUsingAlso() {
+        val restClient = RestClient("http://www.someurl.com")
+
+        val logger = Logger()
+
+        val headers = restClient
+            .getResponse()
+            .also { logger.info(it.toString()) }
+            .headers
+
+        assertTrue {
+            logger.wasCalled() && headers.headerInfo.equals("some header info")
+        }
+
+    }
+
+    @Test
+    fun shouldInitializeFieldWhenAlsoUsed() {
+        val aStudent = Student().also { it.name = "John"}
+
+        assertTrue {
+            aStudent.name.equals("John")
+        }
+    }
+
+    @Test
+    fun shouldLogicallyGroupObjectCallsWhenUsingWith() {
+        val bankAccount = BankAccount(1000)
+        with (bankAccount) {
+            checkAuthorization("someone")
+            addPayee("some payee")
+            makePayment("payment information")
+        }
+    }
+
+    @Test
+    fun shouldConvertObjectWhenRunUsed() {
+        val stringBuider = StringBuilder()
+        val numberOfCharacters = stringBuider.run {
+            append("This is a transformation function.")
+            append("It takes a StringBuilder instance and returns the number of characters in the generated String")
+            length
+        }
+
+        assertTrue {
+            numberOfCharacters == 128
+        }
+    }
+
+    @Test
+    fun shouldHandleNullabilityWhenRunIsUsed() {
+        val message: String? = "hello there!"
+        val charactersInMessage = message?.run {
+            "At this point is safe to reference the variable. Let's print the message: $this"
+        } ?: "default value"
+
+        assertTrue {
+            charactersInMessage.equals("At this point is safe to reference the variable. Let's print the message: hello there!")
+        }
+    }
+
+}

gson/README.md

@@ -11,3 +11,5 @@
 - [Convert JSON to a Map Using Gson](https://www.baeldung.com/gson-json-to-map)
 - [Working with Primitive Values in Gson](https://www.baeldung.com/java-gson-primitives)
 - [Convert String to JsonObject with Gson](https://www.baeldung.com/gson-string-to-jsonobject)
+- [Mapping Multiple JSON Fields to One Java Field](https://www.baeldung.com/json-multiple-fields-single-java-field)
+

jackson-2/.gitignore

@@ -0,0 +1,13 @@
+*.class
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+
+# Packaged files #
+*.jar
+*.war
+*.ear

jackson-2/README.md

@@ -0,0 +1,9 @@
+=========
+
+## Jackson Cookbooks and Examples
+
+###The Course
+The "REST With Spring" Classes: http://bit.ly/restwithspring
+
+### Relevant Articles: 
+- [Mapping Multiple JSON Fields to One Java Field](https://www.baeldung.com/json-multiple-fields-single-java-field)

jackson-2/pom.xml

@@ -0,0 +1,52 @@
+<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>jackson-2</artifactId>
+    <version>0.1-SNAPSHOT</version>
+    <name>jackson-2</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+
+        <!-- marshalling -->
+
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
+
+
+        <!-- test scoped -->
+
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>jackson-2</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+    </build>
+
+    <properties>
+
+        <!-- testing -->
+        <assertj.version>3.11.0</assertj.version>
+    </properties>
+
+</project>

jackson-2/src/main/resources/logback.xml

@@ -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>

java-dates-2/.gitignore

@@ -0,0 +1,29 @@
+*.class
+
+0.*
+
+#folders#
+/target
+/neoDb*
+/data
+/src/main/webapp/WEB-INF/classes
+*/META-INF/*
+.resourceCache
+
+# Packaged files #
+*.jar
+*.war
+*.ear
+
+# Files generated by integration tests
+*.txt
+backup-pom.xml
+/bin/
+/temp
+
+#IntelliJ specific
+.idea/
+*.iml
+
+#jenv
+.java-version

java-dates-2/pom.xml

@@ -0,0 +1,55 @@
+<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>
+    <groupId>com.baeldung</groupId>
+    <artifactId>java-dates-2</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
+    <name>java-dates-2</name>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <!-- test scoped -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>java-dates-2</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source}</source>
+                    <target>${maven.compiler.target}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <!-- testing -->
+        <assertj.version>3.6.1</assertj.version>
+        <maven.compiler.source>1.9</maven.compiler.source>
+        <maven.compiler.target>1.9</maven.compiler.target>
+    </properties>
+</project>

java-dates-2/src/test/java/com/baeldung/xmlgregoriancalendar/XmlGregorianCalendarConverterUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.xmlgregoriancalendar;
+
+import org.junit.Test;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeConstants;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import java.time.LocalDate;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class XmlGregorianCalendarConverterUnitTest {
+
+    @Test
+    public void fromLocalDateToXMLGregorianCalendar() throws DatatypeConfigurationException {
+        LocalDate localDate = LocalDate.of(2017, 4, 25);
+        XMLGregorianCalendar xmlGregorianCalendar = DatatypeFactory.newInstance().newXMLGregorianCalendar(localDate.toString());
+
+        assertThat(xmlGregorianCalendar.getYear()).isEqualTo(localDate.getYear());
+        assertThat(xmlGregorianCalendar.getMonth()).isEqualTo(localDate.getMonthValue());
+        assertThat(xmlGregorianCalendar.getDay()).isEqualTo(localDate.getDayOfMonth());
+        assertThat(xmlGregorianCalendar.getTimezone()).isEqualTo(DatatypeConstants.FIELD_UNDEFINED);
+    }
+
+    @Test
+    public void fromXMLGregorianCalendarToLocalDate() throws DatatypeConfigurationException {
+        XMLGregorianCalendar xmlGregorianCalendar = DatatypeFactory.newInstance().newXMLGregorianCalendar("2017-04-25");
+        LocalDate localDate = LocalDate.of(xmlGregorianCalendar.getYear(), xmlGregorianCalendar.getMonth(), xmlGregorianCalendar.getDay());
+
+        assertThat(localDate.getYear()).isEqualTo(xmlGregorianCalendar.getYear());
+        assertThat(localDate.getMonthValue()).isEqualTo(xmlGregorianCalendar.getMonth());
+        assertThat(localDate.getDayOfMonth()).isEqualTo(xmlGregorianCalendar.getDay());
+    }
+
+}

kotlin-libraries/pom.xml

@@ -19,6 +19,14 @@
             <name>exposed</name>
             <url>https://dl.bintray.com/kotlin/exposed</url>
         </repository>
+        <repository>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+            <id>kotlinx</id>
+            <name>bintray</name>
+            <url>https://dl.bintray.com/kotlin/kotlinx</url>
+        </repository>
     </repositories>
 
     <dependencies>
@@ -112,9 +120,30 @@
             <version>3.3.0</version>
             <type>pom</type>
         </dependency>
+
+        <!-- https://mvnrepository.com/artifact/junit/junit -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>27.1-jre</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-collections-immutable -->
+        <dependency>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-collections-immutable</artifactId>
+            <version>0.1</version>
+        </dependency>
     </dependencies>
 
     <properties>
+        <junit.version>4.12</junit.version>
         <mockito-kotlin.version>1.5.0</mockito-kotlin.version>
         <kodein.version>4.1.0</kodein.version>
         <klaxon.version>3.0.4</klaxon.version>

kotlin-libraries/src/test/kotlin/com/baeldung/kotlin/immutable/KotlinxImmutablesUnitTest.kt

@@ -0,0 +1,27 @@
+package com.baeldung.kotlin.immutable
+
+import junit.framework.Assert.assertEquals
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.immutableListOf
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+
+class KotlinxImmutablesUnitTest{
+
+
+  @Rule
+  @JvmField
+  var ee : ExpectedException = ExpectedException.none()
+
+  @Test
+  fun givenKICLList_whenAddTried_checkExceptionThrown(){
+
+      val list: ImmutableList<String> = immutableListOf("I", "am", "immutable")
+
+      list.add("My new item")
+
+      assertEquals(listOf("I", "am", "immutable"), list)
+
+  }
+}

kotlin-libraries/src/test/kotlin/com/baeldung/kotlin/immutable/ReadOnlyUnitTest.kt

@@ -0,0 +1,73 @@
+package com.baeldung.kotlin.immutable
+
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.ImmutableSet
+import junit.framework.Assert.assertEquals
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.ExpectedException
+
+class ReadOnlyUnitTest{
+
+    @Test
+    fun givenReadOnlyList_whenCastToMutableList_checkNewElementsAdded(){
+
+        val list: List<String> = listOf("This", "Is", "Totally", "Immutable")
+
+        (list as MutableList<String>)[2] = "Not"
+
+        assertEquals(listOf("This", "Is", "Not", "Immutable"), list)
+
+    }
+
+    @Rule
+    @JvmField
+    var ee : ExpectedException = ExpectedException.none()
+
+    @Test
+    fun givenImmutableList_whenAddTried_checkExceptionThrown(){
+
+        val list: List<String> = ImmutableList.of("I", "am", "actually", "immutable")
+
+        ee.expect(UnsupportedOperationException::class.java)
+
+        (list as MutableList<String>).add("Oops")
+
+    }
+
+    @Test
+    fun givenMutableList_whenCopiedAndAddTried_checkExceptionThrown(){
+
+        val mutableList : List<String> = listOf("I", "Am", "Definitely", "Immutable")
+
+        (mutableList as MutableList<String>)[2] = "100% Not"
+
+        assertEquals(listOf("I", "Am", "100% Not", "Immutable"), mutableList)
+
+        val list: List<String> = ImmutableList.copyOf(mutableList)
+
+        ee.expect(UnsupportedOperationException::class.java)
+
+        (list as MutableList<String>)[2] = "Really?"
+
+    }
+
+    @Test
+    fun givenImmutableSetBuilder_whenAddTried_checkExceptionThrown(){
+
+        val mutableList : List<String> = listOf("Hello", "Baeldung")
+        val set: ImmutableSet<String> = ImmutableSet.builder<String>()
+                .add("I","am","immutable")
+                .addAll(mutableList)
+                .build()
+
+        assertEquals(setOf("Hello", "Baeldung", "I", "am", "immutable"), set)
+
+        ee.expect(UnsupportedOperationException::class.java)
+
+        (set as MutableSet<String>).add("Oops")
+
+    }
+
+
+}