Merge branch 'master' into JAVA-18133

.gitignore

@@ -107,4 +107,7 @@ spring-boot-modules/spring-boot-properties-3/*.log
 .sdkmanrc
 
 # Localstack
-**/.localstack
+**/.localstack
+
+#web-modules/ninja
+devDb*.db

README.md

@@ -31,7 +31,7 @@ The projects are broadly divided into 3 lists: first, second and heavy.
 
 Next, they are segregated further on the basis of the tests that we want to execute.
 
-Additionally, there are 2 profiles dedicated for JDK9 and above builds.
+Additionally, there are 2 profiles dedicated for JDK9 and above builds - **which require JDK 17**.
 
 We also have a parents profile to build only parent modules.
 

apache-libraries/src/main/java/com/baeldung/avro/util/serialization/AvroDeSerializer.java

@@ -1,4 +1,4 @@
-package com.baeldung.avro.util.serealization;
+package com.baeldung.avro.util.serialization;
 
 import com.baeldung.avro.util.model.AvroHttpRequest;
 import org.apache.avro.io.DatumReader;
@@ -10,11 +10,11 @@ import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 
-public class AvroDeSerealizer {
+public class AvroDeSerializer {
 
-    private static Logger logger = LoggerFactory.getLogger(AvroDeSerealizer.class);
+    private static Logger logger = LoggerFactory.getLogger(AvroDeSerializer.class);
 
-    public AvroHttpRequest deSerealizeAvroHttpRequestJSON(byte[] data) {
+    public AvroHttpRequest deSerializeAvroHttpRequestJSON(byte[] data) {
         DatumReader<AvroHttpRequest> reader = new SpecificDatumReader<>(AvroHttpRequest.class);
         Decoder decoder = null;
         try {
@@ -27,7 +27,7 @@ public class AvroDeSerealizer {
         return null;
     }
 
-    public AvroHttpRequest deSerealizeAvroHttpRequestBinary(byte[] data) {
+    public AvroHttpRequest deSerializeAvroHttpRequestBinary(byte[] data) {
         DatumReader<AvroHttpRequest> employeeReader = new SpecificDatumReader<>(AvroHttpRequest.class);
         Decoder decoder = DecoderFactory.get()
             .binaryDecoder(data, null);

apache-libraries/src/main/java/com/baeldung/avro/util/serialization/AvroSerializer.java

@@ -1,4 +1,4 @@
-package com.baeldung.avro.util.serealization;
+package com.baeldung.avro.util.serialization;
 
 import com.baeldung.avro.util.model.AvroHttpRequest;
 import org.apache.avro.io.*;
@@ -9,11 +9,11 @@ import org.slf4j.LoggerFactory;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 
-public class AvroSerealizer {
+public class AvroSerializer {
 
-    private static final Logger logger = LoggerFactory.getLogger(AvroSerealizer.class);
+    private static final Logger logger = LoggerFactory.getLogger(AvroSerializer.class);
 
-    public byte[] serealizeAvroHttpRequestJSON(AvroHttpRequest request) {
+    public byte[] serializeAvroHttpRequestJSON(AvroHttpRequest request) {
         DatumWriter<AvroHttpRequest> writer = new SpecificDatumWriter<>(AvroHttpRequest.class);
         byte[] data = new byte[0];
         ByteArrayOutputStream stream = new ByteArrayOutputStream();
@@ -30,7 +30,7 @@ public class AvroSerealizer {
         return data;
     }
 
-    public byte[] serealizeAvroHttpRequestBinary(AvroHttpRequest request) {
+    public byte[] serializeAvroHttpRequestBinary(AvroHttpRequest request) {
         DatumWriter<AvroHttpRequest> writer = new SpecificDatumWriter<>(AvroHttpRequest.class);
         byte[] data = new byte[0];
         ByteArrayOutputStream stream = new ByteArrayOutputStream();

apache-libraries/src/test/java/com/baeldung/avro/util/serialization/AvroSerializerDeSerializerIntegrationTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.avro.util.serealization;
+package com.baeldung.avro.util.serialization;
 
 import com.baeldung.avro.util.model.Active;
 import com.baeldung.avro.util.model.AvroHttpRequest;
@@ -13,16 +13,16 @@ import java.util.Objects;
 
 import static org.junit.Assert.*;
 
-public class AvroSerealizerDeSerealizerIntegrationTest {
+public class AvroSerializerDeSerializerIntegrationTest {
 
-    AvroSerealizer serealizer;
-    AvroDeSerealizer deSerealizer;
+    AvroSerializer serializer;
+    AvroDeSerializer deserializer;
     AvroHttpRequest request;
 
     @Before
     public void setUp() throws Exception {
-        serealizer = new AvroSerealizer();
-        deSerealizer = new AvroDeSerealizer();
+        serializer = new AvroSerializer();
+        deserializer = new AvroDeSerializer();
 
         ClientIdentifier clientIdentifier = ClientIdentifier.newBuilder()
             .setHostName("localhost")
@@ -49,22 +49,22 @@ public class AvroSerealizerDeSerealizerIntegrationTest {
 
     @Test
     public void WhenSerializedUsingJSONEncoder_thenObjectGetsSerialized() {
-        byte[] data = serealizer.serealizeAvroHttpRequestJSON(request);
+        byte[] data = serializer.serializeAvroHttpRequestJSON(request);
         assertTrue(Objects.nonNull(data));
         assertTrue(data.length > 0);
     }
 
     @Test
     public void WhenSerializedUsingBinaryEncoder_thenObjectGetsSerialized() {
-        byte[] data = serealizer.serealizeAvroHttpRequestBinary(request);
+        byte[] data = serializer.serializeAvroHttpRequestBinary(request);
         assertTrue(Objects.nonNull(data));
         assertTrue(data.length > 0);
     }
 
     @Test
     public void WhenDeserializeUsingJSONDecoder_thenActualAndExpectedObjectsAreEqual() {
-        byte[] data = serealizer.serealizeAvroHttpRequestJSON(request);
-        AvroHttpRequest actualRequest = deSerealizer.deSerealizeAvroHttpRequestJSON(data);
+        byte[] data = serializer.serializeAvroHttpRequestJSON(request);
+        AvroHttpRequest actualRequest = deserializer.deSerializeAvroHttpRequestJSON(data);
         assertEquals(actualRequest, request);
         assertTrue(actualRequest.getRequestTime()
             .equals(request.getRequestTime()));
@@ -72,12 +72,12 @@ public class AvroSerealizerDeSerealizerIntegrationTest {
 
     @Test
     public void WhenDeserializeUsingBinaryecoder_thenActualAndExpectedObjectsAreEqual() {
-        byte[] data = serealizer.serealizeAvroHttpRequestBinary(request);
-        AvroHttpRequest actualRequest = deSerealizer.deSerealizeAvroHttpRequestBinary(data);
+        byte[] data = serializer.serializeAvroHttpRequestBinary(request);
+        AvroHttpRequest actualRequest = deserializer.deSerializeAvroHttpRequestBinary(data);
         assertEquals(actualRequest, request);
         assertTrue(actualRequest.getRequestTime()
             .equals(request.getRequestTime()));
     }
-    
+
 }
 

azure/pom.xml

@@ -36,8 +36,8 @@
             <scope>runtime</scope>
         </dependency>
         <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
             <scope>runtime</scope>
         </dependency>
     </dependencies>

core-groovy-modules/core-groovy-2/pom.xml

@@ -155,8 +155,9 @@
 
     <repositories>
         <repository>
-            <id>central</id>
-            <url>https://jcenter.bintray.com</url>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
@@ -167,4 +168,4 @@
         <groovy.compiler.version>3.3.0-01</groovy.compiler.version>
     </properties>
 
-</project>
+</project>

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/category/BaeldungCategory.groovy

@@ -1,17 +1,17 @@
-package com.baeldung.category;
+package com.baeldung.category
 
 class BaeldungCategory {
 
-    public static String capitalize(String self) {
-        String capitalizedStr = self;
+    static String capitalize(String self) {
+        String capitalizedStr = self
         if (self.size() > 0) {
-            capitalizedStr = self.substring(0, 1).toUpperCase() + self.substring(1);
+            capitalizedStr = self.substring(0, 1).toUpperCase() + self.substring(1)
         }
+        
         return capitalizedStr
     }
-    
-    public static double toThePower(Number self, Number exponent) {
-        return Math.pow(self, exponent);
-    }
 
+    static double toThePower(Number self, Number exponent) {
+        return Math.pow(self, exponent)
+    }
 }

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/category/NumberCategory.groovy

@@ -1,17 +1,15 @@
-package com.baeldung.category;
-
-import groovy.lang.Category
+package com.baeldung.category
 
 @Category(Number)
 class NumberCategory {
 
-    public Number cube() {
-        return this*this*this
+    Number cube() {
+        return this**3
     }
 
-    public int divideWithRoundUp(BigDecimal divisor, boolean isRoundUp) {
+    int divideWithRoundUp(BigDecimal divisor, boolean isRoundUp) {
         def mathRound = isRoundUp ? BigDecimal.ROUND_UP : BigDecimal.ROUND_DOWN
-        return (int)new BigDecimal(this).divide(divisor, 0, mathRound)
+        
+        return (int) new BigDecimal(this).divide(divisor, 0, mathRound)
     }
-
 }

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/determinedatatype/Person.groovy

@@ -1,14 +1,19 @@
 package com.baeldung.determinedatatype
 
 class Person {
-    
-    private int ageAsInt
-    private Double ageAsDouble
-    private String ageAsString
-    
+
+    int ageAsInt
+    Double ageAsDouble
+    String ageAsString
+
     Person() {}
-    Person(int ageAsInt) { this.ageAsInt =  ageAsInt}
-    Person(Double ageAsDouble) { this.ageAsDouble =  ageAsDouble}
-    Person(String ageAsString) { this.ageAsString =  ageAsString}    
+
+    Person(int ageAsInt) { this.ageAsInt = ageAsInt }
+
+    Person(Double ageAsDouble) { this.ageAsDouble = ageAsDouble }
+
+    Person(String ageAsString) { this.ageAsString = ageAsString }
+}
+
+class Student extends Person {
 }
-class Student extends Person {}

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/metaprogramming/Employee.groovy

@@ -1,18 +1,14 @@
 package com.baeldung.metaprogramming
 
-import groovy.transform.AutoClone
-import groovy.transform.Canonical
-import groovy.transform.EqualsAndHashCode
-import groovy.transform.ToString
-import groovy.transform.TupleConstructor
-import groovy.util.logging.*
+import groovy.transform.*
+import groovy.util.logging.Log
 
-@Canonical
+@ToString(includePackage = false, excludes = ['id'])
 @TupleConstructor
 @EqualsAndHashCode
-@ToString(includePackage=false, excludes=['id'])
-@Log 
-@AutoClone
+@Canonical
+@AutoClone(style = AutoCloneStyle.SIMPLE)
+@Log
 class Employee {
 
     long id
@@ -30,16 +26,15 @@ class Employee {
     def propertyMissing(String propertyName, propertyValue) {
         println "property '$propertyName' is not available"
         log.info "$propertyName is not available"
-        "property '$propertyName' is not available"
+        "property '$propertyName' with value '$propertyValue' is not available"
     }
 
-    def methodMissing(String methodName, def methodArgs) {
+    def methodMissing(String methodName, Object methodArgs) {
         log.info "$methodName is not defined"
         "method '$methodName' is not defined"
     }
-    
+
     def logEmp() {
         log.info "Employee: $lastName, $firstName is of $age years age"
     }
-
-}
+}

core-groovy-modules/core-groovy-2/src/main/groovy/com/baeldung/metaprogramming/extension/BasicExtensions.groovy

@@ -2,32 +2,31 @@ package com.baeldung.metaprogramming.extension
 
 import com.baeldung.metaprogramming.Employee
 
-import java.time.LocalDate
 import java.time.Year
 
 class BasicExtensions {
-    
+
     static int getYearOfBirth(Employee self) {
         return Year.now().value - self.age
     }
-    
+
     static String capitalize(String self) {
         return self.substring(0, 1).toUpperCase() + self.substring(1)
     }
 
     static void printCounter(Integer self) {
-        while (self>0) {
+        while (self > 0) {
             println self
             self--
         }
     }
-    
+
     static Long square(Long self) {
-        return self*self
+        return self * self
     }
-    
+
     static BigDecimal cube(BigDecimal self) {
-        return self*self*self
+        return self * self * self
     }
-    
-}
+
+}

core-groovy-modules/core-groovy-2/src/test/groovy/com/baeldung/category/CategoryUnitTest.groovy

@@ -1,17 +1,17 @@
 package com.baeldung.category
 
-import groovy.time.*
+import groovy.time.TimeCategory
+import groovy.xml.DOMBuilder
+import groovy.xml.QName
+import groovy.xml.dom.DOMCategory
+
 import java.text.SimpleDateFormat
-import groovy.xml.*
-import groovy.xml.dom.*
-import com.baeldung.category.BaeldungCategory
-import com.baeldung.category.NumberCategory
 
 class CategoryUnitTest extends GroovyTestCase {
 
     void test_whenUsingTimeCategory_thenOperationOnDate() {
         def jan_1_2019 = new Date("01/01/2019")
-        use (TimeCategory) {
+        use(TimeCategory) {
             assert jan_1_2019 + 10.seconds == new Date("01/01/2019 00:00:10")
 
             assert jan_1_2019 + 20.minutes == new Date("01/01/2019 00:20:00")
@@ -30,7 +30,7 @@ class CategoryUnitTest extends GroovyTestCase {
 
     void test_whenUsingTimeCategory_thenOperationOnNumber() {
         SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy")
-        use (TimeCategory) {
+        use(TimeCategory) {
             assert sdf.format(5.days.from.now) == sdf.format(new Date() + 5.days)
 
             sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
@@ -57,7 +57,7 @@ class CategoryUnitTest extends GroovyTestCase {
 
         def root = baeldungArticlesDom.documentElement
 
-        use (DOMCategory) {
+        use(DOMCategory) {
             assert root.article.size() == 2
 
             def articles = root.article
@@ -75,27 +75,26 @@ class CategoryUnitTest extends GroovyTestCase {
             assert root.article[2].title.text() == "Metaprogramming in Groovy"
         }
     }
-    
+
     void test_whenUsingBaeldungCategory_thenCapitalizeString() {
-        use (BaeldungCategory) {
+        use(BaeldungCategory) {
             assert "norman".capitalize() == "Norman"
-        } 
+        }
     }
-    
+
     void test_whenUsingBaeldungCategory_thenOperationsOnNumber() {
-        use (BaeldungCategory) {
+        use(BaeldungCategory) {
             assert 50.toThePower(2) == 2500
             assert 2.4.toThePower(4) == 33.1776
         }
     }
-    
+
     void test_whenUsingNumberCategory_thenOperationsOnNumber() {
-        use (NumberCategory) {
+        use(NumberCategory) {
             assert 3.cube() == 27
             assert 25.divideWithRoundUp(6, true) == 5
             assert 120.23.divideWithRoundUp(6.1, true) == 20
             assert 150.9.divideWithRoundUp(12.1, false) == 12
         }
     }
-
 }

core-groovy-modules/core-groovy-2/src/test/groovy/com/baeldung/determinedatatype/PersonTest.groovy

@@ -1,56 +1,68 @@
 package com.baeldung.determinedatatype
 
-import org.junit.Assert
-import org.junit.Test
-import com.baeldung.determinedatatype.Person
+import spock.lang.Specification
 
-public class PersonTest {
-    
-    @Test
-    public void givenWhenParameterTypeIsInteger_thenReturnTrue() {
+class PersonTest extends Specification {
+
+    def "givenWhenParameterTypeIsIntegerThenReturnTrue"() {
+        given:
         Person personObj = new Person(10)
-        Assert.assertTrue(personObj.ageAsInt instanceof Integer)
-    }
-    
-    @Test
-    public void givenWhenParameterTypeIsDouble_thenReturnTrue() {
-        Person personObj = new Person(10.0)
-        Assert.assertTrue((personObj.ageAsDouble).getClass() == Double)
-    }
-    
-    @Test
-    public void givenWhenParameterTypeIsString_thenReturnTrue() {
-        Person personObj = new Person("10 years")
-        Assert.assertTrue(personObj.ageAsString.class == String)
-    }
-    
-    @Test
-    public void givenClassName_WhenParameterIsInteger_thenReturnTrue() {
-        Assert.assertTrue(Person.class.getDeclaredField('ageAsInt').type == int.class)
-    }
-    
-    @Test
-    public void givenWhenObjectIsInstanceOfType_thenReturnTrue() {
-        Person personObj = new Person()
-        Assert.assertTrue(personObj instanceof Person)
+
+        expect:
+        personObj.ageAsInt.class == Integer
     }
 
-    @Test
-    public void givenWhenInstanceIsOfSubtype_thenReturnTrue() {
+    def "givenWhenParameterTypeIsDouble_thenReturnTrue"() {
+        given:
+        Person personObj = new Person(10.0)
+
+        expect:
+        personObj.ageAsDouble.class == Double
+    }
+
+    def "givenWhenParameterTypeIsString_thenReturnTrue"() {
+        given:
+        Person personObj = new Person("10 years")
+
+        expect:
+        personObj.ageAsString.class == String
+    }
+
+    def "givenClassName_WhenParameterIsInteger_thenReturnTrue"() {
+        expect:
+        Person.class.getDeclaredField('ageAsInt').type == int.class
+    }
+
+    def "givenWhenObjectIsInstanceOfType_thenReturnTrue"() {
+        given:
+        Person personObj = new Person()
+
+        expect:
+        personObj.class == Person
+    }
+
+    def "givenWhenInstanceIsOfSubtype_thenReturnTrue"() {
+        given:
         Student studentObj = new Student()
-        Assert.assertTrue(studentObj in Person)
+
+        expect:
+        studentObj.class.superclass == Person
     }
-    
-    @Test
-    public void givenGroovyList_WhenFindClassName_thenReturnTrue() {
-      def ageList = ['ageAsString','ageAsDouble', 10]   
-      Assert.assertTrue(ageList.class == ArrayList)     
-      Assert.assertTrue(ageList.getClass() == ArrayList)
+
+    def "givenGroovyList_WhenFindClassName_thenReturnTrue"() {
+        given:
+        def ageList = ['ageAsString', 'ageAsDouble', 10]
+
+        expect:
+        ageList.class == ArrayList
+        ageList.getClass() == ArrayList
     }
-    
-    @Test
-    public void givenGrooyMap_WhenFindClassName_thenReturnTrue() {
-      def ageMap = [ageAsString: '10 years', ageAsDouble: 10.0]
-      Assert.assertFalse(ageMap.class == LinkedHashMap)
+
+    def "givenGroovyMap_WhenFindClassName_thenReturnTrue"() {
+        given:
+        def ageMap = [ageAsString: '10 years', ageAsDouble: 10.0]
+
+        expect:
+        ageMap.getClass() == LinkedHashMap
     }
-}
+}

core-groovy-modules/core-groovy-2/src/test/groovy/com/baeldung/metaprogramming/MetaprogrammingUnitTest.groovy

@@ -1,123 +1,163 @@
 package com.baeldung.metaprogramming
 
+import spock.lang.Specification
 
-import java.time.LocalDate
-import java.time.Period
 import java.time.Year
 
-class MetaprogrammingUnitTest extends GroovyTestCase {
+class MetaprogrammingUnitTest extends Specification {
 
-    Employee emp = new Employee(firstName: "Norman", lastName: "Lewis")
+    Employee emp
 
-    void testPropertyMissing() {
-        assert emp.address == "property 'address' is not available"
+    void setup() {
+        emp = new Employee(firstName: "Norman", lastName: "Lewis")
     }
 
-    void testMethodMissing() {
+    def "testPropertyMissing"() {
+        expect:
+        emp.address == "property 'address' is not available"
+    }
+
+    def "testMethodMissing"() {
+        given:
         Employee emp = new Employee()
-        try {
-            emp.getFullName()
-        } catch(MissingMethodException e) {
-            println "method is not defined"
-        }
-        assert emp.getFullName() == "method 'getFullName' is not defined"
+
+        expect:
+        emp.getFullName() == "method 'getFullName' is not defined"
     }
 
-    void testMetaClassProperty() {
+    def "testMetaClassProperty"() {
+        when:
         Employee.metaClass.address = ""
-        emp = new Employee(firstName: "Norman", lastName: "Lewis", address: "US")
-        assert emp.address == "US"
+
+        and:
+        emp = new Employee(firstName: "Norman",
+                           lastName: "Lewis",
+                           address: "US")
+
+        then:
+        emp.address == "US"
     }
 
-    void testMetaClassMethod() {
+    def "testMetaClassMethod"() {
+        when:
         emp.metaClass.getFullName = {
             "$lastName, $firstName"
         }
-        assert emp.getFullName() == "Lewis, Norman"
+
+        then:
+        emp.getFullName() == "Lewis, Norman"
     }
 
-    void testMetaClassConstructor() {
-        try {
-            Employee emp = new Employee("Norman")
-        } catch(GroovyRuntimeException e) {
-            assert e.message == "Could not find matching constructor for: com.baeldung.metaprogramming.Employee(String)"
-        }
+    def "testOnlyNameConstructor"() {
+        when:
+        new Employee("Norman")
 
+        then:
+        thrown(GroovyRuntimeException)
+    }
+
+    def "testMetaClassConstructor"() {
+        when:
         Employee.metaClass.constructor = { String firstName ->
             new Employee(firstName: firstName)
         }
 
+        and:
         Employee norman = new Employee("Norman")
-        assert norman.firstName == "Norman"
-        assert norman.lastName == null
+
+        then:
+        norman.firstName == "Norman"
+        norman.lastName == null
     }
 
-    void testJavaMetaClass() {
+    def "testJavaMetaClass"() {
+        when:
         String.metaClass.capitalize = { String str ->
             str.substring(0, 1).toUpperCase() + str.substring(1)
         }
-        assert "norman".capitalize() == "Norman"
+
+        and:
+        String.metaClass.static.joinWith = { String delimiter, String... args ->
+            String.join(delimiter, args)
+        }
+
+        then:
+        "norman".capitalize() == "Norman"
+        String.joinWith(" -> ", "a", "b", "c") == "a -> b -> c"
     }
 
-    void testEmployeeExtension() {
+    def "testEmployeeExtension"() {
+        given:
         def age = 28
         def expectedYearOfBirth = Year.now() - age
         Employee emp = new Employee(age: age)
-        assert emp.getYearOfBirth() == expectedYearOfBirth.value
+
+        expect:
+        emp.getYearOfBirth() == expectedYearOfBirth.value
     }
 
-    void testJavaClassesExtensions() {
+    def "testJavaClassesExtensions"() {
+        when:
         5.printCounter()
 
-        assert 40l.square() == 1600l
-
-        assert (2.98).cube() == 26.463592
+        then:
+        40L.square() == 1600L
+        (2.98).cube() == 26.463592
     }
 
-    void testStaticEmployeeExtension() {
+    def "testStaticEmployeeExtension"() {
         assert Employee.getDefaultObj().firstName == "firstName"
         assert Employee.getDefaultObj().lastName == "lastName"
         assert Employee.getDefaultObj().age == 20
     }
 
-    void testToStringAnnotation() {
-        Employee employee = new Employee()
-        employee.id = 1
-        employee.firstName = "norman"
-        employee.lastName = "lewis"
-        employee.age = 28
+    def "testToStringAnnotation"() {
+        when:
+        Employee employee = new Employee().tap {
+            id = 1
+            firstName = "norman"
+            lastName = "lewis"
+            age = 28
+        }
 
-        assert employee.toString() == "Employee(norman, lewis, 28)"
+        then:
+        employee.toString() == "Employee(norman, lewis, 28)"
     }
 
-    void testTupleConstructorAnnotation() {
+    def "testTupleConstructorAnnotation"() {
+        when:
         Employee norman = new Employee(1, "norman", "lewis", 28)
-        assert norman.toString() == "Employee(norman, lewis, 28)"
-
         Employee snape = new Employee(2, "snape")
-        assert snape.toString() == "Employee(snape, null, 0)"
 
+        then:
+        norman.toString() == "Employee(norman, lewis, 28)"
+        snape.toString() == "Employee(snape, null, 0)"
     }
-    
-    void testEqualsAndHashCodeAnnotation() {
+
+    def "testEqualsAndHashCodeAnnotation"() {
+        when:
         Employee norman = new Employee(1, "norman", "lewis", 28)
         Employee normanCopy = new Employee(1, "norman", "lewis", 28)
-        assert norman.equals(normanCopy)
-        assert norman.hashCode() == normanCopy.hashCode()
-    }
-    
-    void testAutoCloneAnnotation() {
-        try {
-            Employee norman = new Employee(1, "norman", "lewis", 28)
-            def normanCopy = norman.clone()
-            assert norman == normanCopy
-        } catch(CloneNotSupportedException e) {
-            e.printStackTrace()
-        }
+
+        then:
+        norman == normanCopy
+        norman.hashCode() == normanCopy.hashCode()
     }
 
-    void testLoggingAnnotation() {
+    def "testAutoCloneAnnotation"() {
+        given:
+        Employee norman = new Employee(1, "norman", "lewis", 28)
+
+        when:
+        def normanCopy = norman.clone()
+
+        then:
+        norman == normanCopy
+    }
+
+    def "testLoggingAnnotation"() {
+        given:
         Employee employee = new Employee(1, "Norman", "Lewis", 28)
-        employee.logEmp()
+        employee.logEmp() // INFO: Employee: Lewis, Norman is of 28 years age
     }
 }

core-groovy-modules/core-groovy-2/src/test/groovy/com/baeldung/templateengine/TemplateEnginesUnitTest.groovy

@@ -1,48 +1,62 @@
 package com.baeldung.templateengine
 
+import groovy.text.GStringTemplateEngine
 import groovy.text.SimpleTemplateEngine
 import groovy.text.StreamingTemplateEngine
-import groovy.text.GStringTemplateEngine
-import groovy.text.XmlTemplateEngine
 import groovy.text.XmlTemplateEngine
 import groovy.text.markup.MarkupTemplateEngine
 import groovy.text.markup.TemplateConfiguration
+import spock.lang.Specification
 
-class TemplateEnginesUnitTest extends GroovyTestCase {
-    
-    def bindMap = [user: "Norman", signature: "Baeldung"]
-    
-    void testSimpleTemplateEngine() {
+class TemplateEnginesUnitTest extends Specification {
+
+    final Map BIND_MAP = [user: "Norman", signature: "Baeldung"]
+
+    def "testSimpleTemplateEngine"() {
+        given:
         def smsTemplate = 'Dear <% print user %>, Thanks for reading our Article. ${signature}'
-        def smsText = new SimpleTemplateEngine().createTemplate(smsTemplate).make(bindMap)
 
-        assert smsText.toString() == "Dear Norman, Thanks for reading our Article. Baeldung"
+        when:
+        def smsText = new SimpleTemplateEngine().createTemplate(smsTemplate).make(BIND_MAP)
+
+        then:
+        smsText.toString() == "Dear Norman, Thanks for reading our Article. Baeldung"
     }
-    
-    void testStreamingTemplateEngine() {
+
+    def "testStreamingTemplateEngine"() {
+        given:
         def articleEmailTemplate = new File('src/main/resources/articleEmail.template')
-        bindMap.articleText = """1. Overview
-This is a tutorial article on Template Engines""" //can be a string larger than 64k
-        
-        def articleEmailText = new StreamingTemplateEngine().createTemplate(articleEmailTemplate).make(bindMap)
-        
-        assert articleEmailText.toString() == """Dear Norman,
-Please read the requested article below.
-1. Overview
-This is a tutorial article on Template Engines
-From,
-Baeldung"""
-        
+        //can be a string larger than 64k
+        BIND_MAP.articleText = """|1. Overview
+                                  |This is a tutorial article on Template Engines""".stripMargin()
+
+        when:
+        def articleEmailText = new StreamingTemplateEngine().createTemplate(articleEmailTemplate).make(BIND_MAP)
+
+        then:
+        articleEmailText.toString() == """|Dear Norman,
+                                          |Please read the requested article below.
+                                          |1. Overview
+                                          |This is a tutorial article on Template Engines
+                                          |From,
+                                          |Baeldung""".stripMargin()
     }
-    
-    void testGStringTemplateEngine() {
+
+    def "testGStringTemplateEngine"() {
+        given:
         def emailTemplate = new File('src/main/resources/email.template')
-        def emailText = new GStringTemplateEngine().createTemplate(emailTemplate).make(bindMap)
-        
-        assert emailText.toString() == "Dear Norman,\nThanks for subscribing our services.\nBaeldung"
+
+        when:
+        def emailText = new GStringTemplateEngine().createTemplate(emailTemplate).make(BIND_MAP)
+
+        then:
+        emailText.toString() == """|Dear Norman,
+                                   |Thanks for subscribing our services.
+                                   |Baeldung""".stripMargin()
     }
-    
-    void testXmlTemplateEngine() {
+
+    def "testXmlTemplateEngine"() {
+        given:
         def emailXmlTemplate = '''<xs xmlns:gsp='groovy-server-pages'>
                                       <gsp:scriptlet>def emailContent = "Thanks for subscribing our services."</gsp:scriptlet>
                                       <email>
@@ -51,11 +65,16 @@ Baeldung"""
                                           <signature>${signature}</signature>
                                       </email>
                                   </xs>'''
-        def emailXml = new XmlTemplateEngine().createTemplate(emailXmlTemplate).make(bindMap)
+
+        when:
+        def emailXml = new XmlTemplateEngine().createTemplate(emailXmlTemplate).make(BIND_MAP)
+
+        then:
         println emailXml.toString()
     }
-    
-    void testMarkupTemplateEngineHtml() {
+
+    def "testMarkupTemplateEngineHtml"() {
+        given:
         def emailHtmlTemplate = """html {
                                        head {
                                            title('Service Subscription Email')
@@ -66,14 +85,16 @@ Baeldung"""
                                            p('Baeldung')
                                        }
                                    }"""
-        
-        
+
+        when:
         def emailHtml = new MarkupTemplateEngine().createTemplate(emailHtmlTemplate).make()
+
+        then:
         println emailHtml.toString()
-        
     }
-    
-    void testMarkupTemplateEngineXml() {
+
+    def "testMarkupTemplateEngineXml"() {
+        given:
         def emailXmlTemplate = """xmlDeclaration()  
                                       xs{
                                           email {
@@ -83,14 +104,18 @@ Baeldung"""
                                           }  
                                       }
                                """
-        TemplateConfiguration config = new TemplateConfiguration()
-        config.autoIndent = true
-        config.autoEscape = true
-        config.autoNewLine = true
+        TemplateConfiguration config = new TemplateConfiguration().with {
+            autoIndent = true
+            autoEscape = true
+            autoNewLine = true
 
+            return it
+        }
+
+        when:
         def emailXml = new MarkupTemplateEngine(config).createTemplate(emailXmlTemplate).make()
-        
+
+        then:
         println emailXml.toString()
     }
-    
-}
+}

core-groovy-modules/core-groovy-collections/pom.xml

@@ -113,9 +113,11 @@
 
     <repositories>
         <repository>
-            <id>central</id>
-            <url>http://jcenter.bintray.com</url>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
-</project>
+
+</project>

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/find/ListFindUnitTest.groovy

@@ -1,58 +1,57 @@
 package com.baeldung.find
 
-import com.baeldung.find.Person
-import org.junit.Test
+import spock.lang.Specification
 
-import static org.junit.Assert.*
+class ListFindUnitTest extends Specification {
 
-class ListFindUnitTest {
-
-    private final personList = [
-      new Person("Regina", "Fitzpatrick", 25),
-      new Person("Abagail", "Ballard", 26),
-      new Person("Lucian", "Walter", 30),
+    final personList = [
+            new Person("Regina", "Fitzpatrick", 25),
+            new Person("Abagail", "Ballard", 26),
+            new Person("Lucian", "Walter", 30),
     ]
 
-    @Test
-    void whenListContainsElement_thenCheckReturnsTrue() {
+    def "whenListContainsElement_thenCheckReturnsTrue"() {
+        given:
         def list = ['a', 'b', 'c']
 
-        assertTrue(list.indexOf('a') > -1)
-        assertTrue(list.contains('a'))
+        expect:
+        list.indexOf('a') > -1
+        list.contains('a')
     }
 
-    @Test
-    void whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue() {
+    def "whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue"() {
+        given:
         def list = ['a', 'b', 'c']
 
-        assertTrue('a' in list)
+        expect:
+        'a' in list
     }
 
-    @Test
-    void givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList() {
-        assertTrue(personList.stream().anyMatch {it.age > 20})
-        assertFalse(personList.stream().allMatch {it.age < 30})
+    def "givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList"() {
+        expect:
+        personList.stream().anyMatch { it.age > 20 }
+        !personList.stream().allMatch { it.age < 30 }
     }
 
-    @Test
-    void givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList() {
-        assertTrue(personList.any {it.age > 20})
-        assertFalse(personList.every {it.age < 30})
+    def "givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList"() {
+        expect:
+        personList.any { it.age > 20 }
+        !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())
+    def "givenListOfPerson_whenUsingStreamFind_thenShouldReturnMatchingElements"() {
+        expect:
+        personList.stream().filter { it.age > 20 }.findAny().isPresent()
+        !personList.stream().filter { it.age > 30 }.findAny().isPresent()
+        personList.stream().filter { it.age > 20 }.findAll().size() == 3
+        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())
+    def "givenListOfPerson_whenUsingCollectionFind_thenShouldReturnMatchingElements"() {
+        expect:
+        personList.find { it.age > 20 } == new Person("Regina", "Fitzpatrick", 25)
+        personList.find { it.age > 30 } == null
+        personList.findAll { it.age > 20 }.size() == 3
+        personList.findAll { it.age > 30 }.isEmpty()
     }
 }

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/find/MapFindUnitTest.groovy

@@ -1,76 +1,81 @@
 package com.baeldung.find
 
-import com.baeldung.find.Person
-import org.junit.Test
+import spock.lang.Specification
 
-import static org.junit.Assert.*
+class MapFindUnitTest extends Specification {
 
-class MapFindUnitTest {
-
-    private final personMap = [
-      Regina : new Person("Regina", "Fitzpatrick", 25),
-      Abagail: new Person("Abagail", "Ballard", 26),
-      Lucian : new Person("Lucian", "Walter", 30)
+    final personMap = [
+            Regina: new Person("Regina", "Fitzpatrick", 25),
+            Abagail: new Person("Abagail", "Ballard", 26),
+            Lucian: new Person("Lucian", "Walter", 30)
     ]
 
-    @Test
-    void whenMapContainsKeyElement_thenCheckReturnsTrue() {
+    def "whenMapContainsKeyElement_thenCheckReturnsTrue"() {
+        given:
         def map = [a: 'd', b: 'e', c: 'f']
 
-        assertTrue(map.containsKey('a'))
-        assertFalse(map.containsKey('e'))
-        assertTrue(map.containsValue('e'))
+        expect:
+        map.containsKey('a')
+        !map.containsKey('e')
+        map.containsValue('e')
     }
 
-    @Test
-    void whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue() {
+    def "whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue"() {
+        given:
         def map = [a: 'd', b: 'e', c: 'f']
 
-        assertTrue('a' in map)
-        assertFalse('f' in map)
+        expect:
+        'a' in map
+        'f' !in map
     }
 
-    @Test
-    void whenMapContainsFalseBooleanValues_thenCheckReturnsFalse() {
+    def "whenMapContainsFalseBooleanValues_thenCheckReturnsFalse"() {
+        given:
         def map = [a: true, b: false, c: null]
 
-        assertTrue(map.containsKey('b'))
-        assertTrue('a' in map)
-        assertFalse('b' in map)
-        assertFalse('c' in map)
+        expect:
+        map.containsKey('b')
+        'a' in map
+        'b' !in map // get value of key 'b' and does the assertion
+        '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"})
+    def "givenMapOfPerson_whenUsingStreamMatching_thenShouldEvaluateMap"() {
+        expect:
+        personMap.keySet().stream()
+                 .anyMatch { it == "Regina" }
+        !personMap.keySet().stream()
+                  .allMatch { it == "Albert" }
+        !personMap.values().stream()
+                  .allMatch { it.age < 30 }
+        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"})
+    def "givenMapOfPerson_whenUsingCollectionMatching_thenShouldEvaluateMap"() {
+        expect:
+        personMap.keySet().any { it == "Regina" }
+        !personMap.keySet().every { it == "Albert" }
+        !personMap.values().every { it.age < 30 }
+        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)
+    def "givenMapOfPerson_whenUsingCollectionFind_thenShouldReturnElements"() {
+        expect:
+        personMap.find { it.key == "Abagail" && it.value.lastname == "Ballard" }
+        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)
+    def "givenMapOfPerson_whenUsingStreamFind_thenShouldReturnElements"() {
+        expect:
+        personMap.entrySet().stream()
+                 .filter { it.key == "Abagail" && it.value.lastname == "Ballard" }
+                 .findAny()
+                 .isPresent()
+
+        personMap.entrySet().stream()
+                 .filter { it.value.age > 20 }
+                 .findAll()
+                 .size() == 3
     }
 }

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/find/Person.groovy

@@ -1,37 +1,10 @@
 package com.baeldung.find
 
+import groovy.transform.Canonical
+
+@Canonical
 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
-    }
+    String firstname
+    String lastname
+    Integer age
 }

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/find/SetFindUnitTest.groovy

@@ -1,16 +1,15 @@
 package com.baeldung.find
 
-import org.junit.Test
+import spock.lang.Specification
 
-import static org.junit.Assert.assertTrue
+class SetFindUnitTest extends Specification {
 
-class SetFindUnitTest {
-
-    @Test
-    void whenSetContainsElement_thenCheckReturnsTrue() {
+    def "whenSetContainsElement_thenCheckReturnsTrue"() {
+        given:
         def set = ['a', 'b', 'c'] as Set
 
-        assertTrue(set.contains('a'))
-        assertTrue('a' in set)
+        expect:
+        set.contains('a')
+        'a' in set
     }
-}
+}

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/iteratemap/IterateMapUnitTest.groovy

@@ -1,85 +1,54 @@
 package com.baeldung.iteratemap
 
-import com.baeldung.find.Person
-import org.junit.Test
+import spock.lang.Specification
 
-import static org.junit.Assert.*
+class IterateMapUnitTest extends Specification {
 
-class IterateMapUnitTest {
-
-    @Test
-    void whenUsingEach_thenMapIsIterated() {
-        def map = [
-                'FF0000' : 'Red',
-                '00FF00' : 'Lime',
-                '0000FF' : 'Blue',
-                'FFFF00' : 'Yellow'
-        ]
+    final Map map = [
+            'FF0000': 'Red',
+            '00FF00': 'Lime',
+            '0000FF': 'Blue',
+            'FFFF00': 'Yellow',
+            'E6E6FA': 'Lavender',
+            'D8BFD8': 'Thistle',
+            'DDA0DD': 'Plum',
+    ]
 
+    def "whenUsingEach_thenMapIsIterated"() {
+        expect:
         map.each { println "Hex Code: $it.key = Color Name: $it.value" }
     }
 
-    @Test
-    void whenUsingEachWithEntry_thenMapIsIterated() {
-        def map = [
-                'E6E6FA' : 'Lavender',
-                'D8BFD8' : 'Thistle',
-                'DDA0DD' : 'Plum',
-        ]
-
+    def "whenUsingEachWithEntry_thenMapIsIterated"() {
+        expect:
         map.each { entry -> println "Hex Code: $entry.key = Color Name: $entry.value" }
     }
 
-    @Test
-    void whenUsingEachWithKeyAndValue_thenMapIsIterated() {
-        def map = [
-                '000000' : 'Black',
-                'FFFFFF' : 'White',
-                '808080' : 'Gray'
-        ]
-
+    def "whenUsingEachWithKeyAndValue_thenMapIsIterated"() {
+        expect:
         map.each { key, val ->
             println "Hex Code: $key = Color Name $val"
         }
     }
 
-    @Test
-    void whenUsingEachWithIndexAndEntry_thenMapIsIterated() {
-        def map = [
-                '800080' : 'Purple',
-                '4B0082' : 'Indigo',
-                '6A5ACD' : 'Slate Blue'
-        ]
-
+    def "whenUsingEachWithIndexAndEntry_thenMapIsIterated"() {
+        expect:
         map.eachWithIndex { entry, index ->
-            def indent = ((index == 0 || index % 2 == 0) ? "   " : "")
+            def indent = index % 2 == 0 ? "   " : ""
             println "$indent Hex Code: $entry.key = Color Name: $entry.value"
         }
     }
 
-    @Test
-    void whenUsingEachWithIndexAndKeyAndValue_thenMapIsIterated() {
-        def map = [
-                'FFA07A' : 'Light Salmon',
-                'FF7F50' : 'Coral',
-                'FF6347' : 'Tomato',
-                'FF4500' : 'Orange Red'
-        ]
-
+    def "whenUsingEachWithIndexAndKeyAndValue_thenMapIsIterated"() {
+        expect:
         map.eachWithIndex { key, val, index ->
-            def indent = ((index == 0 || index % 2 == 0) ? "   " : "")
+            def indent = index % 2 == 0 ? "   " : ""
             println "$indent Hex Code: $key = Color Name: $val"
         }
     }
 
-    @Test
-    void whenUsingForLoop_thenMapIsIterated() {
-        def map = [
-                '2E8B57' : 'Seagreen',
-                '228B22' : 'Forest Green',
-                '008000' : 'Green'
-        ]
-
+    def "whenUsingForLoop_thenMapIsIterated"() {
+        expect:
         for (entry in map) {
             println "Hex Code: $entry.key = Color Name: $entry.value"
         }

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

@@ -1,173 +1,171 @@
 package com.baeldung.lists
 
-import static groovy.test.GroovyAssert.*
-import org.junit.Test
+import spock.lang.Specification
 
-class ListUnitTest {
-
-    @Test
-    void testCreateList() {
+class ListUnitTest extends Specification {
 
+    def "testCreateList"() {
+        when:
         def list = [1, 2, 3]
-        assertNotNull(list)
-
         def listMix = ['A', "b", 1, true]
-        assertTrue(listMix == ['A', "b", 1, true])
-
         def linkedList = [1, 2, 3] as LinkedList
-        assertTrue(linkedList instanceof LinkedList)
-
         ArrayList arrList = [1, 2, 3]
-        assertTrue(arrList.class == ArrayList)
-
         def copyList = new ArrayList(arrList)
-        assertTrue(copyList == arrList)
-
         def cloneList = arrList.clone()
-        assertTrue(cloneList == arrList)
+
+        then:
+        list
+        listMix == ['A', "b", 1, true]
+        linkedList instanceof LinkedList
+        arrList.class == ArrayList
+        copyList == arrList
+        cloneList == arrList
     }
 
-    @Test
-    void testCreateEmptyList() {
-
+    def "testCreateEmptyList"() {
+        when:
         def emptyList = []
-        assertTrue(emptyList.size() == 0)
+
+        then:
+        emptyList.isEmpty()
     }
 
-    @Test
-    void testCompareTwoLists() {
-
+    def "testCompareTwoLists"() {
+        when:
         def list1 = [5, 6.0, 'p']
         def list2 = [5, 6.0, 'p']
-        assertTrue(list1 == list2)
+
+        then:
+        list1 == list2
     }
 
-    @Test
-    void testGetItemsFromList(){
-
+    def "testGetItemsFromList"() {
+        when:
         def list = ["Hello", "World"]
 
-        assertTrue(list.get(1) == "World")
-        assertTrue(list[1] == "World")
-        assertTrue(list[-1] == "World")
-        assertTrue(list.getAt(1) == "World")
-        assertTrue(list.getAt(-2) == "Hello")
+        then:
+        list.get(1) == "World"
+        list[1] == "World"
+        list[-1] == "World"
+        list.getAt(1) == "World"
+        list.getAt(-2) == "Hello"
     }
 
-    @Test
-    void testAddItemsToList() {
+    def "testAddItemsToList"() {
+        given:
+        def list1 = []
+        def list2 = []
+        def list3 = [1, 2]
 
-        def list = []
+        when:
+        list1 << 1 // [1]
+        list1.add("Apple") // [1, "Apple"]
 
-        list << 1
-        list.add("Apple")
-        assertTrue(list == [1, "Apple"])
+        list2[2] = "Box"   // [null, "Box"]
+        list2[4] = true    // [null, "Box", null, true]
 
-        list[2] = "Box"
-        list[4] = true
-        assertTrue(list == [1, "Apple", "Box", null, true])
+        list1.add(1, 6.0) // [1, 6.0, "Apple"] 
+        list1 += list3                    // [1, 6.0, "Apple", 1, 2]
+        list1 += 12                       // [1, 6.0, "Apple", 1, 2, 12]
 
-        list.add(1, 6.0)
-        assertTrue(list == [1, 6.0, "Apple", "Box", null, true])
-
-        def list2 = [1, 2]
-        list += list2
-        list += 12
-        assertTrue(list == [1, 6.0, "Apple", "Box", null, true, 1, 2, 12])
+        then:
+        list1 == [1, 6.0, "Apple", 1, 2, 12]
+        list2 == [null, null, "Box", null, true]
     }
 
-    @Test
-    void testUpdateItemsInList() {
+    def "testUpdateItemsInList"() {
+        given:
+        def list = [1, "Apple", 80, "App"]
 
-        def list =[1, "Apple", 80, "App"]
+        when:
         list[1] = "Box"
-        list.set(2,90)
-        assertTrue(list == [1, "Box", 90, "App"])
+        list.set(2, 90)
+
+        then:
+        list == [1, "Box", 90, "App"]
     }
 
-    @Test
-    void testRemoveItemsFromList(){
-
+    def "testRemoveItemsFromList"() {
+        given:
         def list = [1, 2, 3, 4, 5, 5, 6, 6, 7]
 
-        list.remove(3)
-        assertTrue(list == [1, 2, 3, 5, 5, 6, 6, 7])
+        when:
+        list.remove(3) // [1, 2, 3, 5, 5, 6, 6, 7]
+        list.removeElement(5) // [1, 2, 3, 5, 6, 6, 7]
+        list = list - 6       // [1, 2, 3, 5, 7]
 
-        list.removeElement(5)
-        assertTrue(list == [1, 2, 3, 5, 6, 6, 7])
-
-        assertTrue(list - 6 == [1, 2, 3, 5, 7])
+        then:
+        list == [1, 2, 3, 5, 7]
     }
 
-    @Test
-    void testIteratingOnAList(){
-
+    def "testIteratingOnAList"() {
+        given:
         def list = [1, "App", 3, 4]
-        list.each{ println it * 2}
 
-        list.eachWithIndex{ it, i -> println "$i : $it" }
+        expect:
+        list.each { println it * 2 }
+        list.eachWithIndex { it, i -> println "$i : $it" }
     }
 
-    @Test
-    void testCollectingToAnotherList(){
-
+    def "testCollectingToAnotherList"() {
+        given:
         def list = ["Kay", "Henry", "Justin", "Tom"]
-        assertTrue(list.collect{"Hi " + it} == ["Hi Kay", "Hi Henry", "Hi Justin", "Hi Tom"])
+
+        when:
+        def collect = list.collect { "Hi " + it }
+
+        then:
+        collect == ["Hi Kay", "Hi Henry", "Hi Justin", "Hi Tom"]
     }
 
-    @Test
-    void testJoinItemsInAList(){
-        assertTrue(["One", "Two", "Three"].join(",") == "One,Two,Three")
+    def "testJoinItemsInAList"() {
+        expect:
+        ["One", "Two", "Three"].join(",") == "One,Two,Three"
     }
 
-    @Test
-    void testFilteringOnLists(){
+    def "testFilteringOnLists"() {
+        given:
         def filterList = [2, 1, 3, 4, 5, 6, 76]
-
-        assertTrue(filterList.find{it > 3} == 4)
-
-        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})
+        expect:
+        filterList.find { it > 3 } == 4
+        filterList.findAll { it > 3 } == [4, 5, 6, 76]
+        filterList.findAll { it instanceof Number } == [2, 1, 3, 4, 5, 6, 76]
+        filterList.grep(Number) == [2, 1, 3, 4, 5, 6, 76]
+        filterList.grep { it > 6 } == [76]
 
+        !(conditionList.every { it < 6 })
+        conditionList.any { it % 2 == 0 }
     }
 
-    @Test
-    void testGetUniqueItemsInAList(){
-        assertTrue([1, 3, 3, 4].toUnique() == [1, 3, 4])
-
+    def "testGetUniqueItemsInAList"() {
+        given:
         def uniqueList = [1, 3, 3, 4]
-        uniqueList.unique()
-        assertTrue(uniqueList == [1, 3, 4])
 
-        assertTrue(["A", "B", "Ba", "Bat", "Cat"].toUnique{ it.size()} == ["A", "Ba", "Bat"])
+        when:
+        uniqueList.unique(true)
+
+        then:
+        [1, 3, 3, 4].toUnique() == [1, 3, 4]
+        uniqueList == [1, 3, 4]
+        ["A", "B", "Ba", "Bat", "Cat"].toUnique { it.size() } == ["A", "Ba", "Bat"]
     }
 
-    @Test
-    void testSorting(){
-
-        assertTrue([1, 2, 1, 0].sort() == [0, 1, 1, 2])
-        Comparator mc = {a,b -> a == b? 0: a < b? 1 : -1}
-
+    def "testSorting"() {
+        given:
+        Comparator naturalOrder = { a, b -> a == b ? 0 : a < b ? -1 : 1 }
         def list = [1, 2, 1, 0]
-        list.sort(mc)
-        assertTrue(list == [2, 1, 1, 0])
-
         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)
+
+        when:
+        list.sort(naturalOrder.reversed())
+
+        then:
+        list == [2, 1, 1, 0]
+        strList.max() == "ppp"
+        [1, 2, 1, 0].sort() == [0, 1, 1, 2]
+        numberList.min(naturalOrder) == 0
     }
-}
+}

core-groovy-modules/core-groovy-collections/src/test/groovy/com/baeldung/maps/MapTest.groovy

@@ -1,148 +1,160 @@
-package com.baeldung.maps;
+package com.baeldung.maps
 
-import static groovy.test.GroovyAssert.*
-import org.junit.Test
+import spock.lang.Specification
 
-class MapTest{
-
-    @Test
-    void createMap() {
+class MapTest extends Specification {
 
+    def "createMap"() {
+        when:
         def emptyMap = [:]
-        assertNotNull(emptyMap)
+        def map = [name: "Jerry", age: 42, city: "New York"]
 
-        assertTrue(emptyMap instanceof java.util.LinkedHashMap)
-
-        def map = [name:"Jerry", age: 42, city: "New York"]
-        assertTrue(map.size() == 3)
+        then:
+        emptyMap != null
+        emptyMap instanceof java.util.LinkedHashMap
+        map.size() == 3
     }
 
-    @Test
-    void addItemsToMap() {
-
-        def map = [name:"Jerry"]
-
-        map["age"] = 42
-
-        map.city = "New York"
-
+    def "addItemsToMap"() {
+        given:
+        def map = [name: "Jerry"]
         def hobbyLiteral = "hobby"
         def hobbyMap = [(hobbyLiteral): "Singing"]
+        def appendToMap = [:]
+
+        when:
+        map["age"] = 42
+        map.city = "New York"
+
         map.putAll(hobbyMap)
 
-        assertTrue(map == [name:"Jerry", age: 42, city: "New York", hobby:"Singing"])
-        assertTrue(hobbyMap.hobby == "Singing")
-        assertTrue(hobbyMap[hobbyLiteral] == "Singing")
-        
-        map.plus([1:20]) // returns new map
+        appendToMap.plus([1: 20])
+        appendToMap << [2: 30]
 
-        map << [2:30]
+        then:
+        map == [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
 
+        hobbyMap.hobby == "Singing"
+        hobbyMap[hobbyLiteral] == "Singing"
+
+        appendToMap == [2: 30] // plus(Map) returns new instance of Map
     }
 
-    @Test
-    void getItemsFromMap() {
-
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
-
-        assertTrue(map["name"] == "Jerry")
-
-        assertTrue(map.name == "Jerry")
-
+    def "getItemsFromMap"() {
+        when:
+        def map = [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
         def propertyAge = "age"
-        assertTrue(map[propertyAge] == 42)
+
+        then:
+        map["name"] == "Jerry"
+        map.name == "Jerry"
+        map[propertyAge] == 42
+        map."$propertyAge" == 42
     }
 
-    @Test
-    void removeItemsFromMap() {
+    def "removeItemsFromMap"() {
+        given:
+        def map = [1: 20, a: 30, 2: 42, 4: 34, ba: 67, 6: 39, 7: 49]
+        def removeAllKeysOfTypeString = [1: 20, a: 30, ba: 67, 6: 39, 7: 49]
+        def retainAllEntriesWhereValueIsEven = [1: 20, a: 30, ba: 67, 6: 39, 7: 49]
 
-        def map = [1:20, a:30, 2:42, 4:34, ba:67, 6:39, 7:49]
+        when:
+        def minusMap = map - [2: 42, 4: 34]
+        removeAllKeysOfTypeString.removeAll { it.key instanceof String }
+        retainAllEntriesWhereValueIsEven.retainAll { it.value % 2 == 0 }
 
-        def minusMap = map.minus([2:42, 4:34]);
-        assertTrue(minusMap == [1:20, a:30, ba:67, 6:39, 7:49])
-
-        minusMap.removeAll{it -> it.key instanceof String}
-        assertTrue( minusMap == [ 1:20, 6:39, 7:49])
-
-        minusMap.retainAll{it -> it.value %2 == 0}
-        assertTrue( minusMap == [1:20])
+        then:
+        minusMap == [1: 20, a: 30, ba: 67, 6: 39, 7: 49]
+        removeAllKeysOfTypeString == [1: 20, 6: 39, 7: 49]
+        retainAllEntriesWhereValueIsEven == [1: 20, a: 30]
     }
 
-    @Test
-    void iteratingOnMaps(){
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
+    def "iteratingOnMaps"() {
+        when:
+        def map = [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
 
-        map.each{ entry -> println "$entry.key: $entry.value" }
-
-        map.eachWithIndex{ entry, i -> println "$i $entry.key: $entry.value" }
-
-        map.eachWithIndex{ key, value, i -> println "$i $key: $value" }
+        then:
+        map.each { entry -> println "$entry.key: $entry.value" }
+        map.eachWithIndex { entry, i -> println "$i $entry.key: $entry.value" }
+        map.eachWithIndex { key, value, i -> println "$i $key: $value" }
     }
 
-    @Test
-    void filteringAndSearchingMaps(){
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
+    def "filteringAndSearchingMaps"() {
+        given:
+        def map = [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
 
-        assertTrue(map.find{ it.value == "New York"}.key == "city")
+        when:
+        def find = map.find { it.value == "New York" }
+        def finaAll = map.findAll { it.value == "New York" }
+        def grep = map.grep { it.value == "New York" }
+        def every = map.every { it -> it.value instanceof String }
+        def any = map.any { it -> it.value instanceof String }
 
-        assertTrue(map.findAll{ it.value == "New York"} == [city : "New York"])
+        then:
+        find.key == "city"
 
-        map.grep{it.value == "New York"}.each{ it -> assertTrue(it.key == "city" && it.value == "New York")}
+        finaAll instanceof Map
+        finaAll == [city: "New York"]
 
-        assertTrue(map.every{it -> it.value instanceof String} == false)
+        grep instanceof Collection
+        grep.each { it -> assert it.key == "city" && it.value == "New York" }
 
-        assertTrue(map.any{it -> it.value instanceof String} == true)
+        every instanceof Boolean
+        !every
+
+        any instanceof Boolean
+        any
     }
 
-    @Test
-    void collect(){
-
-        def map = [1: [name:"Jerry", age: 42, city: "New York"],
-            2: [name:"Long", age: 25, city: "New York"],
-            3: [name:"Dustin", age: 29, city: "New York"],
-            4: [name:"Dustin", age: 34, city: "New York"]]
-
-        def names = map.collect{entry -> entry.value.name} // returns only list
-        assertTrue(names == ["Jerry", "Long", "Dustin", "Dustin"])
-
-        def uniqueNames = map.collect([] as HashSet){entry -> entry.value.name}
-        assertTrue(uniqueNames == ["Jerry", "Long", "Dustin"] as Set)
-
-        def idNames = map.collectEntries{key, value -> [key, value.name]}
-        assertTrue(idNames == [1:"Jerry", 2: "Long", 3:"Dustin", 4: "Dustin"])
-
-        def below30Names = map.findAll{it.value.age < 30}.collect{key, value -> value.name}
-        assertTrue(below30Names == ["Long", "Dustin"])
+    def "collect"() {
+        given:
+        def map = [
+                1: [name: "Jerry", age: 42, city: "New York"],
+                2: [name: "Long", age: 25, city: "New York"],
+                3: [name: "Dustin", age: 29, city: "New York"],
+                4: [name: "Dustin", age: 34, city: "New York"]
+        ]
 
+        when:
+        def names = map.collect { entry -> entry.value.name } // returns only list
+        def uniqueNames = map.collect { entry -> entry.value.name }
+                             .unique()
+        def idNames = map.collectEntries { key, value -> [key, value.name] }
+        def below30Names = map.findAll { it.value.age < 30 }
+                              .collect { key, value -> value.name }
 
+        then:
+        names == ["Jerry", "Long", "Dustin", "Dustin"]
+        uniqueNames == ["Jerry", "Long", "Dustin"]
+        idNames == [1: "Jerry", 2: "Long", 3: "Dustin", 4: "Dustin"]
+        below30Names == ["Long", "Dustin"]
     }
 
-    @Test
-    void group(){
-        def map = [1:20, 2: 40, 3: 11, 4: 93]
-
-        def subMap = map.groupBy{it.value % 2}
-        println subMap
-        assertTrue(subMap == [0:[1:20, 2:40 ], 1:[3:11, 4:93]])
+    def "group"() {
+        given:
+        def map = [1: 20, 2: 40, 3: 11, 4: 93]
 
+        when:
+        def subMap = map.groupBy { it.value % 2 }
         def keySubMap = map.subMap([1, 2])
-        assertTrue(keySubMap == [1:20, 2:40])
 
+        then:
+        subMap == [0: [1: 20, 2: 40], 1: [3: 11, 4: 93]]
+        keySubMap == [1: 20, 2: 40]
     }
 
-    @Test
-    void sorting(){
-        def map = [ab:20, a: 40, cb: 11, ba: 93]
+    def "sorting"() {
+        given:
+        def map = [ab: 20, a: 40, cb: 11, ba: 93]
 
+        when:
         def naturallyOrderedMap = map.sort()
-        assertTrue([a:40, ab:20, ba:93, cb:11] == naturallyOrderedMap)
-
         def compSortedMap = map.sort({ k1, k2 -> k1 <=> k2 } as Comparator)
-        assertTrue([a:40, ab:20, ba:93, cb:11] == compSortedMap)
-
         def cloSortedMap = map.sort({ it1, it2 -> it1.value <=> it1.value })
-        assertTrue([cb:11, ab:20, a:40, ba:93] == cloSortedMap)
 
+        then:
+        naturallyOrderedMap == [a: 40, ab: 20, ba: 93, cb: 11]
+        compSortedMap == [a: 40, ab: 20, ba: 93, cb: 11]
+        cloSortedMap == [cb: 11, ab: 20, a: 40, ba: 93]
     }
-
 }

core-groovy-modules/core-groovy-strings/pom.xml

@@ -103,9 +103,10 @@
 
     <repositories>
         <repository>
-            <id>central</id>
-            <url>https://jcenter.bintray.com</url>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
-</project>
+</project>

core-groovy-modules/core-groovy-strings/src/test/groovy/com/baeldung/removeprefix/RemovePrefixTest.groovy

@@ -1,70 +1,74 @@
 package com.baeldung.removeprefix
 
-import org.junit.Assert
-import org.junit.Test
+import spock.lang.Specification
 
-class RemovePrefixTest {
+class RemovePrefixTest extends Specification {
 
-
-    @Test
-    public void whenCasePrefixIsRemoved_thenReturnTrue() {
+    def "whenCasePrefixIsRemoved_thenReturnTrue"() {
+        given:
         def trimPrefix = {
             it.startsWith('Groovy-') ? it.minus('Groovy-') : it
         }
-        
+
+        when:
         def actual = trimPrefix("Groovy-Tutorials at Baeldung")
         def expected = "Tutorials at Baeldung"
 
-        Assert.assertEquals(expected, actual)
+        then:
+        expected == actual
     }
 
-    @Test
-    public void whenPrefixIsRemoved_thenReturnTrue() {
-
+    def "whenPrefixIsRemoved_thenReturnTrue"() {
+        given:
         String prefix = "groovy-"
         String trimPrefix = "Groovy-Tutorials at Baeldung"
-        def actual;
-        if(trimPrefix.startsWithIgnoreCase(prefix)) {
+
+        when:
+        def actual
+        if (trimPrefix.startsWithIgnoreCase(prefix)) {
             actual = trimPrefix.substring(prefix.length())
         }
-        
         def expected = "Tutorials at Baeldung"
 
-        Assert.assertEquals(expected, actual)
+        then:
+        expected == actual
     }
 
-    @Test
-    public void whenPrefixIsRemovedUsingRegex_thenReturnTrue() {
-
+    def "whenPrefixIsRemovedUsingRegex_thenReturnTrue"() {
+        given:
         def regex = ~"^([Gg])roovy-"
         String trimPrefix = "Groovy-Tutorials at Baeldung"
+
+        when:
         String actual = trimPrefix - regex
-        
         def expected = "Tutorials at Baeldung"
 
-        Assert.assertEquals(expected, actual)
+        then:
+        expected == actual
     }
 
-    @Test 
-    public void whenPrefixIsRemovedUsingReplaceFirst_thenReturnTrue() {
-        def regex = ~"^groovy" 
-        String trimPrefix = "groovyTutorials at Baeldung's groovy page" 
+    def "whenPrefixIsRemovedUsingReplaceFirst_thenReturnTrue"() {
+        given:
+        def regex = ~"^groovy"
+        String trimPrefix = "groovyTutorials at Baeldung's groovy page"
+
+        when:
         String actual = trimPrefix.replaceFirst(regex, "")
-        
         def expected = "Tutorials at Baeldung's groovy page"
-        
-        Assert.assertEquals(expected, actual)
+
+        then:
+        expected == actual
     }
 
-    @Test
-    public void whenPrefixIsRemovedUsingReplaceAll_thenReturnTrue() {
-
+    def "whenPrefixIsRemovedUsingReplaceAll_thenReturnTrue"() {
+        given:
         String trimPrefix = "groovyTutorials at Baeldung groovy"
+
+        when:
         String actual = trimPrefix.replaceAll(/^groovy/, "")
-        
         def expected = "Tutorials at Baeldung groovy"
 
-        Assert.assertEquals(expected, actual)
+        then:
+        expected == actual
     }
-
-}
+}

core-groovy-modules/core-groovy/pom.xml

@@ -3,6 +3,7 @@
     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-groovy</artifactId>
     <version>1.0-SNAPSHOT</version>
     <name>core-groovy</name>
@@ -103,9 +104,10 @@
 
     <repositories>
         <repository>
-            <id>central</id>
-            <url>https://jcenter.bintray.com</url>
+            <id>maven_central</id>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
-</project>
+</project>

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/file/ReadFile.groovy

@@ -10,13 +10,14 @@ class ReadFile {
     int readFileLineByLine(String filePath) {
         File file = new File(filePath)
         def line, noOfLines = 0;
+
         file.withReader { reader ->
-            while ((line = reader.readLine())!=null)
-            {
+            while ((line = reader.readLine()) != null) {
                 println "${line}"
                 noOfLines++
             }
         }
+
         return noOfLines
     }
 
@@ -26,9 +27,7 @@ class ReadFile {
      * @return
      */
     List<String> readFileInList(String filePath) {
-        File file = new File(filePath)
-        def lines = file.readLines()
-        return lines
+        return new File(filePath).readLines()
     }
 
     /**
@@ -37,9 +36,7 @@ class ReadFile {
      * @return
      */
     String readFileString(String filePath) {
-        File file = new File(filePath)
-        String fileContent = file.text
-        return fileContent
+        return new File(filePath).text
     }
 
     /**
@@ -48,9 +45,7 @@ class ReadFile {
      * @return
      */
     String readFileStringWithCharset(String filePath) {
-        File file = new File(filePath)
-        String utf8Content = file.getText("UTF-8")
-        return utf8Content
+        return new File(filePath).getText("UTF-8")
     }
 
     /**
@@ -59,49 +54,44 @@ class ReadFile {
      * @return
      */
     byte[] readBinaryFile(String filePath) {
-        File file = new File(filePath)
-        byte[] binaryContent = file.bytes
-        return binaryContent
+        return new File(filePath).bytes
     }
-    
+
     /**
      * More Examples of reading a file 
      * @return
      */
     def moreExamples() {
-        
+
         //with reader with utf-8
         new File("src/main/resources/utf8Content.html").withReader('UTF-8') { reader ->
             def line
-            while ((line = reader.readLine())!=null) { 
+            while ((line = reader.readLine()) != null) {
                 println "${line}"
             }
         }
-        
-        //collect api
-        def list = new File("src/main/resources/fileContent.txt").collect {it}
-                
-        //as operator
+
+        // collect api
+        def list = new File("src/main/resources/fileContent.txt").collect { it }
+
+        // as operator
         def array = new File("src/main/resources/fileContent.txt") as String[]
-              
-        //eachline  
-        new File("src/main/resources/fileContent.txt").eachLine { line ->
-            println line
-        }
-        
+
+        // eachline  
+        new File("src/main/resources/fileContent.txt").eachLine { println it }
+
         //newInputStream with eachLine
-        def is = new File("src/main/resources/fileContent.txt").newInputStream()
-        is.eachLine {
-            println it
+
+        // try-with-resources automatically closes BufferedInputStream resource
+        try (def inputStream = new File("src/main/resources/fileContent.txt").newInputStream()) {
+            inputStream.eachLine { println it }
         }
-        is.close()
-        
-        //withInputStream
+
+        // withInputStream
         new File("src/main/resources/fileContent.txt").withInputStream { stream ->
             stream.eachLine { line ->
                 println line
             }
         }
     }
-
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/strings/Concatenate.groovy

@@ -1,9 +1,10 @@
 package com.baeldung.strings;
 
 class Concatenate {
+
     String first = 'Hello'
     String last = 'Groovy'
-  
+
     String doSimpleConcat() {
         return 'My name is ' + first + ' ' + last
     }
@@ -23,21 +24,28 @@ class Concatenate {
     String doConcatUsingLeftShiftOperator() {
         return 'My name is ' << first << ' ' << last
     }
-    
+
     String doConcatUsingArrayJoinMethod() {
         return ['My name is', first, last].join(' ')
     }
 
     String doConcatUsingArrayInjectMethod() {
-        return  [first,' ', last]
-          .inject(new StringBuffer('My name is '), { initial, name -> initial.append(name); return initial }).toString()
+        return [first, ' ', last]
+                .inject(new StringBuffer('My name is '), { initial, name -> initial.append(name) })
+                .toString()
     }
- 
+
     String doConcatUsingStringBuilder() {
-        return new StringBuilder().append('My name is ').append(first).append(' ').append(last)
+        return new StringBuilder().append('My name is ')
+                                  .append(first)
+                                  .append(' ')
+                                  .append(last)
     }
 
     String doConcatUsingStringBuffer() {
-        return new StringBuffer().append('My name is ').append(first).append(' ').append(last)
+        return new StringBuffer().append('My name is ')
+                                 .append(first)
+                                 .append(' ')
+                                 .append(last)
     }
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/AnimalTrait.groovy

@@ -1,8 +1,8 @@
 package com.baeldung.traits
 
 trait AnimalTrait {
-    
+
     String basicBehavior() {
         return "Animalistic!!"
     }
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/Dog.groovy

@@ -1,9 +1,8 @@
 package com.baeldung.traits
 
 class Dog implements WalkingTrait, SpeakingTrait {
-     
+    
     String speakAndWalk() {
         WalkingTrait.super.speakAndWalk()
     }
-    
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/Employee.groovy

@@ -1,12 +1,14 @@
 package com.baeldung.traits
 
 class Employee implements UserTrait {
-    
+
+    @Override
     String name() {
         return 'Bob'
     }
     
+    @Override
     String lastName() {
         return "Marley"
     }
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/Human.groovy

@@ -1,6 +1,6 @@
 package com.baeldung.traits
 
 interface Human {
-    
+
     String lastName()
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/SpeakingTrait.groovy

@@ -1,13 +1,12 @@
 package com.baeldung.traits
 
 trait SpeakingTrait {
-    
+
     String basicAbility() {
         return "Speaking!!"
     }
-    
+
     String speakAndWalk() {
         return "Speak and walk!!"
     }
-    
-}
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/UserTrait.groovy

@@ -1,36 +1,35 @@
 package com.baeldung.traits
 
 trait UserTrait implements Human {
-    
+
+    String email
+    String address
+
+    abstract String name()
+
     String sayHello() {
         return "Hello!"
     }
-    
-    abstract String name()
-    
+
     String showName() {
-       return "Hello, ${name()}!"
+        return "Hello, ${name()}!"
     }
 
     private String greetingMessage() {
         return 'Hello, from a private method!'
     }
-    
+
     String greet() {
         def msg = greetingMessage()
         println msg
         msg
     }
-    
+
     def self() {
-        return this 
+        return this
     }
-    
+
     String showLastName() {
         return "Hello, ${lastName()}!"
     }
-    
-    String email
-    String address
 }
-    

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/VehicleTrait.groovy

@@ -1,9 +1,9 @@
 package com.baeldung
 
 trait VehicleTrait extends WheelTrait {
-    
+
     String showWheels() {
-        return "Num of Wheels $noOfWheels" 
+        return "Num of Wheels $noOfWheels"
     }
-    
-}
+
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/WalkingTrait.groovy

@@ -1,13 +1,13 @@
 package com.baeldung.traits
 
 trait WalkingTrait {
-    
+
     String basicAbility() {
         return "Walking!!"
     }
-    
+
     String speakAndWalk() {
         return "Walk and speak!!"
     }
-    
-}
+
+}

core-groovy-modules/core-groovy/src/main/groovy/com/baeldung/traits/WheelTrait.groovy

@@ -1,7 +1,6 @@
 package com.baeldung
 
 trait WheelTrait {
-    
+
     int noOfWheels
-    
-}
+}

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/file/ReadFileUnitTest.groovy

@@ -1,71 +1,76 @@
 package com.baeldung.file
 
 import spock.lang.Specification
-import spock.lang.Ignore
 
 class ReadFileUnitTest extends Specification {
 
     ReadFile readFile
 
-    void setup () {
+    void setup() {
         readFile = new ReadFile()
     }
 
-    def 'Should return number of lines in File using ReadFile.readFileLineByLine given filePath' () {
+    def 'Should return number of lines in File using ReadFile.readFileLineByLine given filePath'() {
         given:
-            def filePath = "src/main/resources/fileContent.txt"
+        def filePath = "src/main/resources/fileContent.txt"
+
         when:
-            def noOfLines = readFile.readFileLineByLine(filePath)
+        def noOfLines = readFile.readFileLineByLine(filePath)
+
         then:
-            noOfLines
-            noOfLines instanceof Integer
-            assert noOfLines, 3
-    }
-    
-    def 'Should return File Content in list of lines using ReadFile.readFileInList given filePath' () {
-        given:
-            def filePath = "src/main/resources/fileContent.txt"
-        when:
-            def lines = readFile.readFileInList(filePath)
-        then:
-            lines
-            lines instanceof List<String>
-            assert lines.size(), 3
-    }
-    
-    def 'Should return file content in string using ReadFile.readFileString given filePath' () {
-        given:
-            def filePath = "src/main/resources/fileContent.txt"
-        when:
-            def fileContent = readFile.readFileString(filePath)
-        then:
-            fileContent
-            fileContent instanceof String
-            fileContent.contains("""Line 1 : Hello World!!!
-Line 2 : This is a file content.
-Line 3 : String content""")
-    
+        noOfLines
+        noOfLines instanceof Integer
+        noOfLines == 3
     }
 
-    def 'Should return UTF-8 encoded file content in string using ReadFile.readFileStringWithCharset given filePath' () {
+    def 'Should return File Content in list of lines using ReadFile.readFileInList given filePath'() {
         given:
-            def filePath = "src/main/resources/utf8Content.html"
+        def filePath = "src/main/resources/fileContent.txt"
+
         when:
-            def encodedContent = readFile.readFileStringWithCharset(filePath)
+        def lines = readFile.readFileInList(filePath)
+
         then:
-            encodedContent
-            encodedContent instanceof String
+        lines
+        lines instanceof List<String>
+        lines.size() == 3
     }
-    
-    def 'Should return binary file content in byte array using ReadFile.readBinaryFile given filePath' () {
+
+    def 'Should return file content in string using ReadFile.readFileString given filePath'() {
         given:
-            def filePath = "src/main/resources/sample.png"
+        def filePath = "src/main/resources/fileContent.txt"
+
         when:
-            def binaryContent = readFile.readBinaryFile(filePath)
+        def fileContent = readFile.readFileString(filePath)
+
         then:
-            binaryContent
-            binaryContent instanceof byte[]
-            binaryContent.length == 329
+        fileContent
+        fileContent instanceof String
+        fileContent.contains(["Line 1 : Hello World!!!", "Line 2 : This is a file content.", "Line 3 : String content"].join("\r\n"))
     }
-    
-}
+
+    def 'Should return UTF-8 encoded file content in string using ReadFile.readFileStringWithCharset given filePath'() {
+        given:
+        def filePath = "src/main/resources/utf8Content.html"
+
+        when:
+        def encodedContent = readFile.readFileStringWithCharset(filePath)
+
+        then:
+        encodedContent
+        encodedContent instanceof String
+    }
+
+    def 'Should return binary file content in byte array using ReadFile.readBinaryFile given filePath'() {
+        given:
+        def filePath = "src/main/resources/sample.png"
+
+        when:
+        def binaryContent = readFile.readBinaryFile(filePath)
+
+        then:
+        binaryContent
+        binaryContent instanceof byte[]
+        binaryContent.length == 329
+    }
+}

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/groovy/sql/SqlTest.groovy

@@ -1,28 +1,29 @@
 package com.baeldung.groovy.sql
 
 import groovy.sql.GroovyResultSet
-import groovy.sql.GroovyRowResult
 import groovy.sql.Sql
-import groovy.transform.CompileStatic
-import static org.junit.Assert.*
 import org.junit.Test
 
+import static org.junit.Assert.*
+
 class SqlTest {
 
-    final Map dbConnParams = [url: 'jdbc:hsqldb:mem:testDB', user: 'sa', password: '', driver: 'org.hsqldb.jdbc.JDBCDriver']
+    final Map dbConnParams = [url: 'jdbc:hsqldb:mem:testDB',
+                              user: 'sa',
+                              password: '',
+                              driver: 'org.hsqldb.jdbc.JDBCDriver']
 
     @Test
     void whenNewSqlInstance_thenDbIsAccessed() {
         def sql = Sql.newInstance(dbConnParams)
         sql.close()
-        sql.close()
     }
 
     @Test
     void whenTableDoesNotExist_thenSelectFails() {
         try {
             Sql.withInstance(dbConnParams) { Sql sql ->
-                sql.eachRow('select * from PROJECT') {}
+                sql.eachRow('SELECT * FROM PROJECT') {}
             }
 
             fail("An exception should have been thrown")
@@ -34,12 +35,12 @@ class SqlTest {
     @Test
     void whenTableCreated_thenSelectIsPossible() {
         Sql.withInstance(dbConnParams) { Sql sql ->
-            def result = sql.execute 'create table PROJECT_1 (id integer not null, name varchar(50), url varchar(100))'
+            def result = sql.execute 'CREATE TABLE PROJECT_1 (ID INTEGER NOT NULL, NAME VARCHAR(50), URL VARCHAR(100))'
 
             assertEquals(0, sql.updateCount)
             assertFalse(result)
 
-            result = sql.execute('select * from PROJECT_1')
+            result = sql.execute('SELECT * FROM PROJECT_1')
 
             assertTrue(result)
         }
@@ -48,7 +49,7 @@ class SqlTest {
     @Test
     void whenIdentityColumn_thenInsertReturnsNewId() {
         Sql.withInstance(dbConnParams) { Sql sql ->
-            sql.execute 'create table PROJECT_2 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+            sql.execute 'CREATE TABLE PROJECT_2 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
             def ids = sql.executeInsert("INSERT INTO PROJECT_2 (NAME, URL) VALUES ('tutorials', 'github.com/eugenp/tutorials')")
 
             assertEquals(0, ids[0][0])
@@ -62,9 +63,10 @@ class SqlTest {
     @Test
     void whenUpdate_thenNumberOfAffectedRows() {
         Sql.withInstance(dbConnParams) { Sql sql ->
-            sql.execute 'create table PROJECT_3 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+            sql.execute 'CREATE TABLE PROJECT_3 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
             sql.executeInsert("INSERT INTO PROJECT_3 (NAME, URL) VALUES ('tutorials', 'github.com/eugenp/tutorials')")
             sql.executeInsert("INSERT INTO PROJECT_3 (NAME, URL) VALUES ('REST with Spring', 'github.com/eugenp/REST-With-Spring')")
+
             def count = sql.executeUpdate("UPDATE PROJECT_3 SET URL = 'https://' + URL")
 
             assertEquals(2, count)
@@ -74,7 +76,7 @@ class SqlTest {
     @Test
     void whenEachRow_thenResultSetHasProperties() {
         Sql.withInstance(dbConnParams) { Sql sql ->
-            sql.execute 'create table PROJECT_4 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+            sql.execute 'CREATE TABLE PROJECT_4 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
             sql.executeInsert("INSERT INTO PROJECT_4 (NAME, URL) VALUES ('tutorials', 'https://github.com/eugenp/tutorials')")
             sql.executeInsert("INSERT INTO PROJECT_4 (NAME, URL) VALUES ('REST with Spring', 'https://github.com/eugenp/REST-With-Spring')")
 
@@ -93,7 +95,7 @@ class SqlTest {
     @Test
     void whenPagination_thenSubsetIsReturned() {
         Sql.withInstance(dbConnParams) { Sql sql ->
-            sql.execute 'create table PROJECT_5 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+            sql.execute 'CREATE TABLE PROJECT_5 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
             sql.executeInsert("INSERT INTO PROJECT_5 (NAME, URL) VALUES ('tutorials', 'github.com/eugenp/tutorials')")
             sql.executeInsert("INSERT INTO PROJECT_5 (NAME, URL) VALUES ('REST with Spring', 'github.com/eugenp/REST-With-Spring')")
             def rows = sql.rows('SELECT * FROM PROJECT_5 ORDER BY NAME', 1, 1)
@@ -106,9 +108,11 @@ class SqlTest {
     @Test
     void whenParameters_thenReplacement() {
         Sql.withInstance(dbConnParams) { Sql sql ->
-            sql.execute 'create table PROJECT_6 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
-            sql.execute('INSERT INTO PROJECT_6 (NAME, URL) VALUES (?, ?)', 'tutorials', 'github.com/eugenp/tutorials')
-            sql.execute("INSERT INTO PROJECT_6 (NAME, URL) VALUES (:name, :url)", [name: 'REST with Spring', url: 'github.com/eugenp/REST-With-Spring'])
+            sql.execute 'CREATE TABLE PROJECT_6 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+            sql.execute('INSERT INTO PROJECT_6 (NAME, URL) VALUES (?, ?)',
+                        'tutorials', 'github.com/eugenp/tutorials')
+            sql.execute("INSERT INTO PROJECT_6 (NAME, URL) VALUES (:name, :url)",
+                        [name: 'REST with Spring', url: 'github.com/eugenp/REST-With-Spring'])
 
             def rows = sql.rows("SELECT * FROM PROJECT_6 WHERE NAME = 'tutorials'")
 
@@ -123,7 +127,7 @@ class SqlTest {
     @Test
     void whenParametersInGString_thenReplacement() {
         Sql.withInstance(dbConnParams) { Sql sql ->
-            sql.execute 'create table PROJECT_7 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+            sql.execute 'CREATE TABLE PROJECT_7 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
             sql.execute "INSERT INTO PROJECT_7 (NAME, URL) VALUES (${'tutorials'}, ${'github.com/eugenp/tutorials'})"
             def name = 'REST with Spring'
             def url = 'github.com/eugenp/REST-With-Spring'
@@ -143,7 +147,7 @@ class SqlTest {
     void whenTransactionRollback_thenNoDataInserted() {
         Sql.withInstance(dbConnParams) { Sql sql ->
             sql.withTransaction {
-                sql.execute 'create table PROJECT_8 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+                sql.execute 'CREATE TABLE PROJECT_8 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
                 sql.executeInsert("INSERT INTO PROJECT_8 (NAME, URL) VALUES ('tutorials', 'https://github.com/eugenp/tutorials')")
                 sql.executeInsert("INSERT INTO PROJECT_8 (NAME, URL) VALUES ('REST with Spring', 'https://github.com/eugenp/REST-With-Spring')")
                 sql.rollback()
@@ -159,7 +163,7 @@ class SqlTest {
     void whenTransactionRollbackThenCommit_thenOnlyLastInserted() {
         Sql.withInstance(dbConnParams) { Sql sql ->
             sql.withTransaction {
-                sql.execute 'create table PROJECT_9 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+                sql.execute 'CREATE TABLE PROJECT_9 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
                 sql.executeInsert("INSERT INTO PROJECT_9 (NAME, URL) VALUES ('tutorials', 'https://github.com/eugenp/tutorials')")
                 sql.rollback()
                 sql.executeInsert("INSERT INTO PROJECT_9 (NAME, URL) VALUES ('REST with Spring', 'https://github.com/eugenp/REST-With-Spring')")
@@ -179,11 +183,12 @@ class SqlTest {
         Sql.withInstance(dbConnParams) { Sql sql ->
             try {
                 sql.withTransaction {
-                    sql.execute 'create table PROJECT_10 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+                    sql.execute 'CREATE TABLE PROJECT_10 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
                     sql.executeInsert("INSERT INTO PROJECT_10 (NAME, URL) VALUES ('tutorials', 'https://github.com/eugenp/tutorials')")
                     throw new Exception('rollback')
                 }
-            } catch (ignored) {}
+            } catch (ignored) {
+            }
 
             def rows = sql.rows("SELECT * FROM PROJECT_10")
 
@@ -196,11 +201,12 @@ class SqlTest {
         Sql.withInstance(dbConnParams) { Sql sql ->
             try {
                 sql.cacheConnection {
-                    sql.execute 'create table PROJECT_11 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+                    sql.execute 'CREATE TABLE PROJECT_11 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
                     sql.executeInsert("INSERT INTO PROJECT_11 (NAME, URL) VALUES ('tutorials', 'https://github.com/eugenp/tutorials')")
                     throw new Exception('This does not rollback')
                 }
-            } catch (ignored) {}
+            } catch (ignored) {
+            }
 
             def rows = sql.rows("SELECT * FROM PROJECT_11")
 
@@ -211,7 +217,7 @@ class SqlTest {
     /*@Test
     void whenModifyResultSet_thenDataIsChanged() {
         Sql.withInstance(dbConnParams) { Sql sql ->
-            sql.execute 'create table PROJECT_5 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
+            sql.execute 'CREATE TABLE PROJECT_5 (ID IDENTITY, NAME VARCHAR (50), URL VARCHAR (100))'
             sql.executeInsert("INSERT INTO PROJECT_5 (NAME, URL) VALUES ('tutorials', 'github.com/eugenp/tutorials')")
             sql.executeInsert("INSERT INTO PROJECT_5 (NAME, URL) VALUES ('REST with Spring', 'github.com/eugenp/REST-With-Spring')")
 

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/json/JsonParserTest.groovy

@@ -1,5 +1,6 @@
 package com.baeldung.json
 
+import groovy.json.JsonGenerator
 import spock.lang.Specification
 
 import java.text.SimpleDateFormat
@@ -8,20 +9,42 @@ class JsonParserTest extends Specification {
 
     JsonParser jsonParser
 
-    void setup () {
+    void setup() {
         jsonParser = new JsonParser()
     }
 
-    def 'Should parse to Account given Json String' () {
+    def 'Should parse to Account given Json String'() {
         given:
-            def json = '{"id":"1234","value":15.6}'
+        def json = '{"id":"1234","value":15.6}'
+
         when:
-            def account = jsonParser.toObject(json)
+        def account = jsonParser.toObject(json)
+
         then:
-            account
-            account instanceof Account
-            account.id == '1234'
-            account.value == 15.6
+        account
+        account instanceof Account
+        account.id == '1234'
+        account.value == 15.6
+    }
+
+    def 'Should format date and exclude value field'() {
+        given:
+        def account = new Account(
+                id: '123',
+                value: 15.6,
+                createdAt: new SimpleDateFormat('MM/dd/yyyy').parse('14/01/2023')
+        )
+
+        def jsonGenerator = new JsonGenerator.Options()
+                .dateFormat('MM/dd/yyyy')
+                .excludeFieldsByName('value')
+                .build()
+
+        when:
+        def accountToJson = jsonGenerator.toJson(account)
+
+        then:
+        accountToJson == '{"createdAt":"01/31/2024","id":"123"}'
     }
 
     /*def 'Should parse to Account given Json String with date property' () {
@@ -52,15 +75,20 @@ class JsonParserTest extends Specification {
             json == '{"value":15.6,"createdAt":"2018-01-01T00:00:00+0000","id":"123"}'
     }*/
 
-    def 'Should prettify given a json string' () {
+    def 'Should prettify given a json string'() {
         given:
-            String json = '{"value":15.6,"createdAt":"01/01/2018","id":"123456"}'
+        String json = '{"value":15.6,"createdAt":"01/01/2018","id":"123456"}'
+
         when:
-            def jsonPretty = jsonParser.prettyfy(json)
+        def jsonPretty = jsonParser.prettyfy(json)
+
         then:
-            jsonPretty
-            jsonPretty == '{\n    "value": 15.6,\n    "createdAt": "01/01/2018",\n    "id": "123456"\n}'
+        jsonPretty
+        jsonPretty == '''\
+{
+    "value": 15.6,
+    "createdAt": "01/01/2018",
+    "id": "123456"
+}'''
     }
-
-
 }

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/strings/ConcatenateTest.groovy

@@ -1,101 +1,88 @@
-import com.baeldung.strings.Concatenate;
+import com.baeldung.strings.Concatenate
+import spock.lang.Specification
 
-class ConcatenateTest extends GroovyTestCase {
-    
-    void testSimpleConcat() {
-        def name = new Concatenate()
-        name.first = 'Joe';
-        name.last = 'Smith';
-        def expected = 'My name is Joe Smith'
-        assertToString(name.doSimpleConcat(), expected)
-    }
-    
-    void testConcatUsingGString() {
-        def name = new Concatenate()
-        name.first = "Joe";
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingGString(), expected)
-    }
-    
-    void testConcatUsingGStringClosures() {
-        def name = new Concatenate()
-        name.first = "Joe";
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingGStringClosures(), expected)
-    }
-    
-    void testConcatUsingStringConcatMethod() {
-        def name = new Concatenate()
-        name.first = "Joe";
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingStringConcatMethod(), expected)
+class ConcatenateTest extends Specification {
+
+    final Concatenate NAME = new Concatenate(first: 'Joe', last: 'Smith')
+    final String EXPECTED = "My name is Joe Smith";
+
+    def "SimpleConcat"() {
+        expect:
+        NAME.doSimpleConcat() == EXPECTED
     }
 
-    void testConcatUsingLeftShiftOperator() {
-        def name = new Concatenate()
-        name.first = "Joe";
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingLeftShiftOperator(), expected)
+    def "ConcatUsingGString"() {
+        expect:
+        NAME.doConcatUsingGString() == EXPECTED
     }
 
-    void testConcatUsingArrayJoinMethod() {
-        def name = new Concatenate()
-        name.first = "Joe";
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingArrayJoinMethod(), expected)
+    def "ConcatUsingGStringClosures"() {
+        expect:
+        NAME.doConcatUsingGStringClosures() == EXPECTED
     }
 
-    void testConcatUsingArrayInjectMethod() {
-        def name = new Concatenate()
-        name.first = "Joe";
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingArrayInjectMethod(), expected)
+    def "ConcatUsingStringConcatMethod"() {
+        expect:
+        NAME.doConcatUsingStringConcatMethod() == EXPECTED
     }
 
-    void testConcatUsingStringBuilder() {
-        def name = new Concatenate()
-        name.first = "Joe";
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingStringBuilder(), expected)
+    def "ConcatUsingLeftShiftOperator"() {
+        expect:
+        NAME.doConcatUsingLeftShiftOperator() == EXPECTED
     }
 
-    void testConcatUsingStringBuffer() {
-        def name = new Concatenate()
-        name.first = "Joe";
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingStringBuffer(), expected)
+    def "ConcatUsingArrayJoinMethod"() {
+        expect:
+        NAME.doConcatUsingArrayJoinMethod() == EXPECTED
     }
 
-    void testConcatMultilineUsingStringConcatMethod() {
-        def name = new Concatenate()
-        name.first = '''Joe
+    def "ConcatUsingArrayInjectMethod"() {
+        expect:
+        NAME.doConcatUsingArrayInjectMethod() == EXPECTED
+    }
+
+    def "ConcatUsingStringBuilder"() {
+        expect:
+        NAME.doConcatUsingStringBuilder() == EXPECTED
+    }
+
+    def "ConcatUsingStringBuffer"() {
+        expect:
+        NAME.doConcatUsingStringBuffer() == EXPECTED
+    }
+
+    def "ConcatMultilineUsingStringConcatMethod"() {
+        when:
+        NAME.first = '''Joe
                         Smith
-                        ''';
-        name.last = 'Junior';
+                        '''
+        NAME.last = 'Junior'
+
+        then:
         def expected = '''My name is Joe
                         Smith
-                         Junior''';
-        assertToString(name.doConcatUsingStringConcatMethod(), expected)
+                         Junior'''
+        NAME.doConcatUsingStringConcatMethod() == expected
     }
 
-    void testGStringvsClosure(){
-        def first = "Joe";
-        def last = "Smith";
-        def eagerGString = "My name is $first $last"
-        def lazyGString = "My name is ${-> first} ${-> last}"
+    def "GStringvsClosure"() {
+        given:
+        def eagerGString = "My name is $NAME.first $NAME.last"
+        def lazyGString = "My name is ${-> NAME.first} ${-> NAME.last}"
 
-        assert eagerGString == "My name is Joe Smith"
-        assert lazyGString == "My name is Joe Smith"
-        first = "David";
-        assert eagerGString == "My name is Joe Smith"
-        assert lazyGString == "My name is David Smith"
-    }  
+        expect:
+        eagerGString == "My name is Joe Smith"
+        lazyGString == "My name is Joe Smith"
+    }
+
+    def "LazyVsEager"() {
+        given:
+        def eagerGString = "My name is $NAME.first $NAME.last"
+        def lazyGString = "My name is ${-> NAME.first} ${-> NAME.last}"
+        NAME.first = "David"
+
+        expect:
+        eagerGString == "My name is Joe Smith"
+        lazyGString == "My name is David Smith"
+    }
 }

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/strings/StringMatchingSpec.groovy

@@ -13,7 +13,7 @@ class StringMatchingSpec extends Specification {
         expect:
         p instanceof Pattern
 
-        and: "you can use slash strings to avoid escaping of blackslash"
+        and: "you can use slash strings to avoid escaping of backslash"
         def digitPattern = ~/\d*/
         digitPattern.matcher('4711').matches()
     }

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/stringtoint/ConvertStringToInt.groovy

@@ -1,110 +1,119 @@
 package com.baeldung.stringtoint
 
-import org.junit.Test
+import spock.lang.Specification
 
 import java.text.DecimalFormat
 
-import static org.junit.Assert.assertEquals
-import static org.junit.Assert.assertNull
+class ConvertStringToInt extends Specification {
 
-class ConvertStringToInt {
+    final String STRING_NUM = "123"
+    final int EXPECTED_INT = 123
 
-    @Test
-    void givenString_whenUsingAsInteger_thenConvertToInteger() {
-        def stringNum = "123"
+    def "givenString_whenUsingAsInteger_thenConvertToInteger"() {
+        given:
         def invalidString = "123a"
-        Integer expectedInteger = 123
-        Integer integerNum = stringNum as Integer
+        Integer integerNum = STRING_NUM as Integer
+
+        when:
         def intNum = invalidString?.isInteger() ? invalidString as Integer : null
 
-        assertNull(null, intNum)
-        assertEquals(integerNum, expectedInteger)
+        then:
+        intNum == null
+        integerNum == EXPECTED_INT
     }
 
-    @Test
-    void givenString_whenUsingAsInt_thenConvertToInt() {
-        def stringNum = "123"
-        int expectedInt = 123
-        int intNum = stringNum as int
+    def "givenString_whenUsingAsInt_thenConvertToInt"() {
+        given:
+        int intNum = STRING_NUM as int
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
-    void givenString_whenUsingToInteger_thenConvertToInteger() {
-        def stringNum = "123"
-        int expectedInt = 123
-        int intNum = stringNum.toInteger()
+    def "givenString_whenUsingToInteger_thenConvertToInteger"() {
+        given:
+        int intNum = STRING_NUM.toInteger()
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
-    void givenString_whenUsingParseInt_thenConvertToInteger() {
-        def stringNum = "123"
-        int expectedInt = 123
-        int intNum = Integer.parseInt(stringNum)
+    def "givenString_whenUsingParseInt_thenConvertToInteger"() {
+        given:
+        int intNum = Integer.parseInt(STRING_NUM)
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
-    void givenString_whenUsingValueOf_thenConvertToInteger() {
-        def stringNum = "123"
-        int expectedInt = 123
-        int intNum = Integer.valueOf(stringNum)
+    def "givenString_whenUsingValueOf_thenConvertToInteger"() {
+        given:
+        int intNum = Integer.valueOf(STRING_NUM)
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
-    void givenString_whenUsingIntValue_thenConvertToInteger() {
-        def stringNum = "123"
-        int expectedInt = 123
-        int intNum = new Integer(stringNum).intValue()
+    def "givenString_whenUsingIntValue_thenConvertToInteger"() {
+        given:
+        int intNum = Integer.valueOf(STRING_NUM).intValue()
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
-    void givenString_whenUsingNewInteger_thenConvertToInteger() {
-        def stringNum = "123"
-        int expectedInt = 123
-        int intNum = new Integer(stringNum)
+    def "givenString_whenUsingNewInteger_thenConvertToInteger"() {
+        given:
+        Integer intNum = Integer.valueOf(STRING_NUM)
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
-    void givenString_whenUsingDecimalFormat_thenConvertToInteger() {
-        def stringNum = "123"
-        int expectedInt = 123
+    def "givenString_whenUsingDecimalFormat_thenConvertToInteger"() {
+        given:
         DecimalFormat decimalFormat = new DecimalFormat("#")
-        int intNum = decimalFormat.parse(stringNum).intValue()
 
-        assertEquals(intNum, expectedInt)
+        when:
+        int intNum = decimalFormat.parse(STRING_NUM).intValue()
+
+        then:
+        intNum == EXPECTED_INT
     }
 
-    @Test(expected = NumberFormatException.class)
-    void givenInvalidString_whenUsingAs_thenThrowNumberFormatException() {
+    def "givenInvalidString_whenUsingAs_thenThrowNumberFormatException"() {
+        given:
         def invalidString = "123a"
+
+        when:
         invalidString as Integer
+
+        then:
+        thrown(NumberFormatException)
     }
 
-    @Test(expected = NullPointerException.class)
-    void givenNullString_whenUsingToInteger_thenThrowNullPointerException() {
+    def "givenNullString_whenUsingToInteger_thenThrowNullPointerException"() {
+        given:
         def invalidString = null
+
+        when:
         invalidString.toInteger()
+
+        then:
+        thrown(NullPointerException)
     }
 
-    @Test
-    void givenString_whenUsingIsInteger_thenCheckIfCorrectValue() {
+    def "givenString_whenUsingIsInteger_thenCheckIfCorrectValue"() {
+        given:
         def invalidString = "123a"
         def validString = "123"
+
+        when:
         def invalidNum = invalidString?.isInteger() ? invalidString as Integer : false
         def correctNum = validString?.isInteger() ? validString as Integer : false
 
-        assertEquals(false, invalidNum)
-        assertEquals(123, correctNum)
+        then:
+        !invalidNum
+        correctNum == 123
     }
 }

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/stringtypes/CharacterInGroovy.groovy

@@ -1,19 +1,18 @@
 package groovy.com.baeldung.stringtypes
 
-import org.junit.Assert
-import org.junit.Test
+import spock.lang.Specification
 
-class CharacterInGroovy {
+class CharacterInGroovy extends Specification {
 
-    @Test
-    void 'character'() {
+    def 'character'() {
+        given:
         char a = 'A' as char
         char b = 'B' as char
         char c = (char) 'C'
 
-        Assert.assertTrue(a instanceof Character)
-        Assert.assertTrue(b instanceof Character)
-        Assert.assertTrue(c instanceof Character)
+        expect:
+        a instanceof Character
+        b instanceof Character
+        c instanceof Character
     }
-
 }

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/stringtypes/DoubleQuotedString.groovy

@@ -1,67 +1,76 @@
 package groovy.com.baeldung.stringtypes
 
-import org.junit.Assert
-import org.junit.Test
+import spock.lang.Specification
 
-class DoubleQuotedString {
+class DoubleQuotedString extends Specification {
 
-    @Test
-    void 'escape double quoted string'() {
+    def 'escape double quoted string'() {
+        given:
         def example = "Hello \"world\"!"
 
-        println(example)
+        expect:
+        example == 'Hello "world"!'
     }
 
-    @Test
-    void 'String ang GString'() {
+    def 'String ang GString'() {
+        given:
         def string = "example"
         def stringWithExpression = "example${2}"
 
-        Assert.assertTrue(string instanceof String)
-        Assert.assertTrue(stringWithExpression instanceof GString)
-        Assert.assertTrue(stringWithExpression.toString() instanceof String)
+        expect:
+        string instanceof String
+        stringWithExpression instanceof GString
+        stringWithExpression.toString() instanceof String
     }
 
-    @Test
-    void 'placeholder with variable'() {
+    def 'placeholder with variable'() {
+        given:
         def name = "John"
+
+        when:
         def helloName = "Hello $name!".toString()
 
-        Assert.assertEquals("Hello John!", helloName)
+        then:
+        helloName == "Hello John!"
     }
 
-    @Test
-    void 'placeholder with expression'() {
+    def 'placeholder with expression'() {
+        given:
         def result = "result is ${2 * 2}".toString()
 
-        Assert.assertEquals("result is 4", result)
+        expect:
+        result == "result is 4"
     }
 
-    @Test
-    void 'placeholder with dotted access'() {
+    def 'placeholder with dotted access'() {
+        given:
         def person = [name: 'John']
 
+        when:
         def myNameIs = "I'm $person.name, and you?".toString()
 
-        Assert.assertEquals("I'm John, and you?", myNameIs)
+        then:
+        myNameIs == "I'm John, and you?"
     }
 
-    @Test
-    void 'placeholder with method call'() {
+    def 'placeholder with method call'() {
+        given:
         def name = 'John'
 
+        when:
         def result = "Uppercase name: ${name.toUpperCase()}".toString()
 
-        Assert.assertEquals("Uppercase name: JOHN", result)
+        then:
+        result == "Uppercase name: JOHN"
     }
 
 
-    @Test
-    void 'GString and String hashcode'() {
+    def 'GString and String hashcode'() {
+        given:
         def string = "2+2 is 4"
         def gstring = "2+2 is ${4}"
 
-        Assert.assertTrue(string.hashCode() != gstring.hashCode())
+        expect:
+        string.hashCode() != gstring.hashCode()
     }
-
 }

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/stringtypes/SingleQuotedString.groovy

@@ -1,15 +1,14 @@
 package groovy.com.baeldung.stringtypes
 
-import org.junit.Assert
-import org.junit.Test
+import spock.lang.Specification
 
-class SingleQuotedString {
+class SingleQuotedString extends Specification {
 
-    @Test
-    void 'single quoted string'() {
-        def example = 'Hello world'
+    def 'single quoted string'() {
+        given:
+        def example = 'Hello world!'
 
-        Assert.assertEquals('Hello world!', 'Hello' + ' world!')
+        expect:
+        example == 'Hello' + ' world!'
     }
-
 }

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/stringtypes/Strings.groovy

@@ -1,26 +1,29 @@
 package groovy.com.baeldung.stringtypes
 
-import org.junit.Assert
-import org.junit.Test
+import spock.lang.Specification
 
-class Strings {
+class Strings extends Specification {
 
-    @Test
-    void 'string interpolation '() {
+    def 'string interpolation '() {
+        given:
         def name = "Kacper"
 
+        when:
         def result = "Hello ${name}!"
 
-        Assert.assertEquals("Hello Kacper!", result.toString())
+        then:
+        result.toString() == "Hello Kacper!"
     }
 
-    @Test
-    void 'string concatenation'() {
+    def 'string concatenation'() {
+        given:
         def first = "first"
         def second = "second"
 
+        when:
         def concatenation = first + second
 
-        Assert.assertEquals("firstsecond", concatenation)
+        then:
+        concatenation == "firstsecond"
     }
 }

core-groovy-modules/core-groovy/src/test/groovy/com/baeldung/traits/TraitsUnitTest.groovy

@@ -7,108 +7,111 @@ class TraitsUnitTest extends Specification {
     Employee employee
     Dog dog
 
-    void setup () {
+    void setup() {
         employee = new Employee()
         dog = new Dog()
     }
 
-    def 'Should return msg string when using Employee.sayHello method provided by UserTrait' () {
+    def 'Should return msg string when using Employee.sayHello method provided by UserTrait'() {
         when:
-            def msg = employee.sayHello()
+        def msg = employee.sayHello()
+
         then:
-            msg
-            msg instanceof String
-            assert msg == "Hello!"
+        msg
+        msg instanceof String
+        msg == "Hello!"
     }
-    
-    def 'Should return displayMsg string when using Employee.showName method' () {
+
+    def 'Should return displayMsg string when using Employee.showName method'() {
         when:
-            def displayMsg = employee.showName()
+        def displayMsg = employee.showName()
+
         then:
-            displayMsg
-            displayMsg instanceof String
-            assert displayMsg == "Hello, Bob!"
+        displayMsg
+        displayMsg instanceof String
+        displayMsg == "Hello, Bob!"
     }
-    
-    def 'Should return greetMsg string when using Employee.greet method' () {
+
+    def 'Should return greetMsg string when using Employee.greet method'() {
         when:
-            def greetMsg = employee.greet()
+        def greetMsg = employee.greet()
+
         then:
-            greetMsg
-            greetMsg instanceof String
-            assert greetMsg == "Hello, from a private method!"
+        greetMsg
+        greetMsg instanceof String
+        greetMsg == "Hello, from a private method!"
     }
-    
-    def 'Should return MissingMethodException when using Employee.greetingMessage method' () {
+
+    def 'Should return MissingMethodException when using Employee.greetingMessage method'() {
         when:
-            def exception
-            try {
-                employee.greetingMessage()
-            }catch(Exception e) {
-                exception = e
-            }
-            
+        employee.greetingMessage()
+
         then:
-            exception
-            exception instanceof groovy.lang.MissingMethodException
-            assert exception.message == "No signature of method: com.baeldung.traits.Employee.greetingMessage()"+
-            " is applicable for argument types: () values: []"
+        thrown(MissingMethodException)
+        specificationContext.thrownException.message ==
+                "No signature of method: com.baeldung.traits.Employee.greetingMessage() is applicable for argument types: () values: []"
     }
-    
-    def 'Should return employee instance when using Employee.whoAmI method' () {
+
+    def 'Should return employee instance when using Employee.whoAmI method'() {
         when:
-            def emp = employee.self()
+        def emp = employee.self()
+
         then:
-            emp
-            emp instanceof Employee
-            assert emp.is(employee)
+        emp
+        emp instanceof Employee
+        emp.is(employee)
     }
-    
-    def 'Should display lastName when using Employee.showLastName method' () {
+
+    def 'Should display lastName when using Employee.showLastName method'() {
         when:
-            def lastNameMsg = employee.showLastName()
+        def lastNameMsg = employee.showLastName()
+
         then:
-            lastNameMsg
-            lastNameMsg instanceof String
-            assert lastNameMsg == "Hello, Marley!"
+        lastNameMsg
+        lastNameMsg instanceof String
+        lastNameMsg == "Hello, Marley!"
     }
-    
-    def 'Should be able to define properties of UserTrait in Employee instance' () {
+
+    def 'Should be able to define properties of UserTrait in Employee instance'() {
         when:
-            employee = new Employee(email: "a@e.com", address: "baeldung.com")
+        employee = new Employee(email: "a@e.com", address: "baeldung.com")
+
         then:
-            employee
-            employee instanceof Employee
-            assert employee.email == "a@e.com"
-            assert employee.address == "baeldung.com"
+        employee
+        employee instanceof Employee
+        employee.email == "a@e.com"
+        employee.address == "baeldung.com"
     }
-    
-    def 'Should execute basicAbility method from SpeakingTrait and return msg string' () {
+
+    def 'Should execute basicAbility method from SpeakingTrait and return msg string'() {
         when:
-            def speakMsg = dog.basicAbility()
+        def speakMsg = dog.basicAbility()
+
         then:
-            speakMsg
-            speakMsg instanceof String
-            assert speakMsg == "Speaking!!"
+        speakMsg
+        speakMsg instanceof String
+        speakMsg == "Speaking!!"
     }
-    
-    def 'Should verify multiple inheritance with traits and execute overridden traits method' () {
+
+    def 'Should verify multiple inheritance with traits and execute overridden traits method'() {
         when:
-            def walkSpeakMsg = dog.speakAndWalk()
-            println walkSpeakMsg
+        def walkSpeakMsg = dog.speakAndWalk()
+        println walkSpeakMsg
+
         then:
-            walkSpeakMsg
-            walkSpeakMsg instanceof String
-            assert walkSpeakMsg == "Walk and speak!!"
+        walkSpeakMsg
+        walkSpeakMsg instanceof String
+        walkSpeakMsg == "Walk and speak!!"
     }
-    
-    def 'Should implement AnimalTrait at runtime and access basicBehavior method' () {
+
+    def 'Should implement AnimalTrait at runtime and access basicBehavior method'() {
         when:
-            def dogInstance = new Dog() as AnimalTrait
-            def basicBehaviorMsg = dogInstance.basicBehavior()
+        def dogInstance = new Dog() as AnimalTrait
+        def basicBehaviorMsg = dogInstance.basicBehavior()
+
         then:
-            basicBehaviorMsg
-            basicBehaviorMsg instanceof String
-            assert basicBehaviorMsg == "Animalistic!!"
+        basicBehaviorMsg
+        basicBehaviorMsg instanceof String
+        basicBehaviorMsg == "Animalistic!!"
     }
-}
+}

core-groovy-modules/pom.xml

@@ -21,12 +21,12 @@
     </modules>
 
     <properties>
-        <groovy.version>2.5.7</groovy.version>
-        <groovy-all.version>2.5.6</groovy-all.version>
-        <groovy-sql.version>2.5.6</groovy-sql.version>
+        <groovy.version>3.0.8</groovy.version>
+        <groovy-all.version>3.0.8</groovy-all.version>
+        <groovy-sql.version>3.0.8</groovy-sql.version>
         <hsqldb.version>2.4.0</hsqldb.version>
-        <spock-core.version>1.1-groovy-2.4</spock-core.version>
+        <spock-core.version>2.3-groovy-3.0</spock-core.version>
         <gmavenplus-plugin.version>1.6</gmavenplus-plugin.version>
     </properties>
 
-</project>
+</project>

core-java-modules/core-java-14/README.md

@@ -12,3 +12,4 @@ This module contains articles about Java 14.
 - [Java 14 Record Keyword](https://www.baeldung.com/java-record-keyword)
 - [New Features in Java 14](https://www.baeldung.com/java-14-new-features)
 - [Java 14 Record vs. Lombok](https://www.baeldung.com/java-record-vs-lombok)
+- [Record vs. Final Class in Java](https://www.baeldung.com/java-record-vs-final-class)

core-java-modules/core-java-17/src/main/java/com/baeldung/java8to17/Address.java

@@ -0,0 +1,40 @@
+package com.baeldung.java8to17;
+
+public class Address {
+
+    private String street;
+    private String city;
+    private String pin;
+
+    public Address(String street, String city, String pin) {
+        super();
+        this.street = street;
+        this.city = city;
+        this.pin = pin;
+    }
+
+    public String getStreet() {
+        return street;
+    }
+
+    public void setStreet(String street) {
+        this.street = street;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public String getPin() {
+        return pin;
+    }
+
+    public void setPin(String pin) {
+        this.pin = pin;
+    }
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/java8to17/Circle.java

@@ -0,0 +1,4 @@
+package com.baeldung.java8to17;
+
+public record Circle(double radius) implements Shape {
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/java8to17/Person.java

@@ -0,0 +1,30 @@
+package com.baeldung.java8to17;
+
+public class Person {
+
+    private String name;
+    private Address address;
+
+    public Person(String name, Address address) {
+        super();
+        this.name = name;
+        this.address = address;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Address getAddress() {
+        return address;
+    }
+
+    public void setAddress(Address address) {
+        this.address = address;
+    }
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/java8to17/Rectangle.java

@@ -0,0 +1,4 @@
+package com.baeldung.java8to17;
+
+public record Rectangle(double length, double width) implements Shape {
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/java8to17/Shape.java

@@ -0,0 +1,5 @@
+package com.baeldung.java8to17;
+
+public interface Shape {
+
+}

core-java-modules/core-java-17/src/main/java/com/baeldung/java8to17/Student.java

@@ -0,0 +1,5 @@
+package com.baeldung.java8to17;
+
+public record Student(int rollNo, String name) {
+
+}

core-java-modules/core-java-17/src/test/java/com/baeldung/java17/Java8to17ExampleUnitTest.java

@@ -0,0 +1,87 @@
+package com.baeldung.java17;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.java8to17.Address;
+import com.baeldung.java8to17.Circle;
+import com.baeldung.java8to17.Person;
+import com.baeldung.java8to17.Rectangle;
+import com.baeldung.java8to17.Student;
+
+public class Java8to17ExampleUnitTest {
+
+    @Test
+    void givenMultiLineText_whenUsingTextBlock_thenStringIsReturned() {
+        String value = """
+            This is a
+            Multi-line
+            Text
+            """;
+        
+        assertThat(value).isEqualTo("This is a\nMulti-line\nText\n");
+    }
+    
+    @Test
+    void givenString_whenUsingUtilFunctions_thenReturnsExpectedResult() {
+        assertThat("  ".isBlank());
+        assertThat("Twinkle ".repeat(2)).isEqualTo("Twinkle Twinkle ");
+        assertThat("Format Line".indent(4)).isEqualTo("    Format Line\n");
+        assertThat("Line 1 \n Line2".lines()).asList().size().isEqualTo(2);
+        assertThat(" Text with white spaces   ".strip()).isEqualTo("Text with white spaces");
+        assertThat("Car, Bus, Train".transform(s1 -> Arrays.asList(s1.split(","))).get(0)).isEqualTo("Car");
+    }
+    
+    @Test
+    void givenDataModel_whenUsingRecordType_thenBehavesLikeDTO() {
+        Student student = new Student(10, "Priya");
+        Student student2 = new Student(10, "Priya");
+        
+        assertThat(student.rollNo()).isEqualTo(10);
+        assertThat(student.name()).isEqualTo("Priya");
+        assertThat(student.equals(student2));
+        assertThat(student.hashCode()).isEqualTo(student2.hashCode());
+    }
+    
+    @Test 
+    void givenObject_whenThrowingNPE_thenReturnsHelpfulMessage() {
+        Person student = new Person("Lakshmi", new Address("35, West Street", null, null));
+        
+        Exception exception = assertThrows(NullPointerException.class, () -> {
+            student.getAddress().getCity().toLowerCase();
+        });
+        
+        assertThat(exception.getMessage()).isEqualTo(
+            "Cannot invoke \"String.toLowerCase()\" because the return value of \"com.baeldung.java8to17.Address.getCity()\" is null");
+    }
+    
+    @Test 
+    void givenGenericObject_whenUsingPatternMatching_thenReturnsTargetType() {
+        String city = null;
+        Object obj = new Address("35, West Street", "Chennai", "6000041");
+
+        if (obj instanceof Address address) {
+            city = address.getCity();
+        }
+        
+        assertThat(city).isEqualTo("Chennai");
+    }
+    
+    @Test 
+    void givenGenericObject_whenUsingSwitchExpression_thenPatternMatchesRightObject() {
+        Object shape = new Rectangle(10, 20);
+        
+        double circumference = switch (shape) {
+            case Rectangle r -> 2 * r.length() + 2 * r.width();
+            case Circle c -> 2 * c.radius() * Math.PI;
+            default -> throw new IllegalArgumentException("Unknown shape");
+        };
+        
+        assertThat(circumference).isEqualTo(60);
+    }
+
+}

core-java-modules/core-java-collections-conversions-2/src/test/java/com/baeldung/combine2liststomap/CombineTwoListsInAMapUnitTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.combine2liststomap;
+
+import static java.lang.Math.min;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import org.junit.jupiter.api.Test;
+
+public class CombineTwoListsInAMapUnitTest {
+    private static final List<String> KEY_LIST = Arrays.asList("Number One", "Number Two", "Number Three", "Number Four", "Number Five");
+    private static final List<Integer> VALUE_LIST = Arrays.asList(1, 2, 3, 4, 5);
+    private static final Map<String, Integer> EXPECTED_MAP = new HashMap<String, Integer>() {{
+        put("Number One", 1);
+        put("Number Two", 2);
+        put("Number Three", 3);
+        put("Number Four", 4);
+        put("Number Five", 5);
+    }};
+
+    @Test
+    void givenTwoLists_whenUsingLoopAndListGet_shouldGetExpectedMap() {
+        Map<String, Integer> result = new HashMap<>();
+        int size = KEY_LIST.size();
+        if (KEY_LIST.size() != VALUE_LIST.size()) {
+            // throw an exception or print a warning
+            size = min(KEY_LIST.size(), VALUE_LIST.size());
+        }
+        for (int i = 0; i < size; i++) {
+            result.put(KEY_LIST.get(i), VALUE_LIST.get(i));
+        }
+        assertEquals(EXPECTED_MAP, result);
+    }
+
+    @Test
+    void givenTwoLists_whenUsingStreamApiAndListGet_shouldGetExpectedMap() {
+        Map<String, Integer> result = IntStream.range(0, KEY_LIST.size())
+          .boxed()
+          .collect(Collectors.toMap(KEY_LIST::get, VALUE_LIST::get));
+        assertEquals(EXPECTED_MAP, result);
+    }
+
+    @Test
+    void givenTwoLists_whenUsingIterators_shouldGetExpectedMap() {
+        Map<String, Integer> result = new HashMap<>();
+
+        Iterator<String> ik = KEY_LIST.iterator();
+        Iterator<Integer> iv = VALUE_LIST.iterator();
+        while (ik.hasNext() && iv.hasNext()) {
+            result.put(ik.next(), iv.next());
+        }
+
+        assertEquals(EXPECTED_MAP, result);
+    }
+
+}

core-java-modules/core-java-collections-maps-6/pom.xml

@@ -0,0 +1,20 @@
+<?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">
+    <artifactId>core-java-collections-maps-6</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-collections-maps-6</name>
+    <packaging>jar</packaging>
+    <parent>
+        <artifactId>core-java-modules</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <properties>
+        <spring.version>5.2.5.RELEASE</spring.version>
+    </properties>
+
+</project>

core-java-modules/core-java-collections-maps-6/src/main/java/com/baeldung/map/hashmapcopy/CopyingAHashMapToAnother.java

@@ -0,0 +1,47 @@
+package com.baeldung.map.hashmapcopy;
+
+import java.util.Map;
+
+import com.google.common.collect.MapDifference;
+import com.google.common.collect.Maps;
+
+public class CopyingAHashMapToAnother {
+    public Map<String, String> copyByIteration(Map<String, String> sourceMap, Map<String, String> targetMap) {
+        for (Map.Entry<String, String> entry : sourceMap.entrySet()) {
+            if (!targetMap.containsKey(entry.getKey())) {
+                targetMap.put(entry.getKey(), entry.getValue());
+            }
+        }
+        return targetMap;
+    }
+
+    public Map<String, String> copyUsingPutAll(Map<String, String> sourceMap, Map<String, String> targetMap) {
+        sourceMap.keySet()
+          .removeAll(targetMap.keySet());
+        targetMap.putAll(sourceMap);
+        return targetMap;
+    }
+
+    public Map<String, String> copyUsingPutIfAbsent(Map<String, String> sourceMap, Map<String, String> targetMap) {
+        for (Map.Entry<String, String> entry : sourceMap.entrySet()) {
+            targetMap.putIfAbsent(entry.getKey(), entry.getValue());
+        }
+        return targetMap;
+    }
+
+    public Map<String, String> copyUsingPutIfAbsentForEach(Map<String, String> sourceMap, Map<String, String> targetMap) {
+        sourceMap.forEach(targetMap::putIfAbsent);
+        return targetMap;
+    }
+
+    public Map<String, String> copyUsingMapMerge(Map<String, String> sourceMap, Map<String, String> targetMap) {
+        sourceMap.forEach((key, value) -> targetMap.merge(key, value, (oldVal, newVal) -> oldVal));
+        return targetMap;
+    }
+
+    public Map<String, String> copyUsingGuavaMapDifference(Map<String, String> sourceMap, Map<String, String> targetMap) {
+        MapDifference<String, String> differenceMap = Maps.difference(sourceMap, targetMap);
+        targetMap.putAll(differenceMap.entriesOnlyOnLeft());
+        return targetMap;
+    }
+}

core-java-modules/core-java-collections-maps-6/src/test/java/com/baeldung/map/hashmapcopy/CopyHashMapIntoAnotherUnitTest.java

@@ -0,0 +1,68 @@
+package com.baeldung.map.hashmapcopy;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.baeldung.map.hashmapcopy.CopyingAHashMapToAnother;
+
+public class CopyHashMapIntoAnotherUnitTest {
+    @Test
+    public void givenSourceAndTargetMapsWhenIteratedOverThenCopyingSuccess(){
+        CopyingAHashMapToAnother obj = new CopyingAHashMapToAnother();
+        Assert.assertEquals(generateExpectedResultMap(), obj.copyByIteration(generateSourceMap(), generateTargetMap()));
+    }
+
+    @Test
+    public void givenSourceAndTargetMapsWhenUsedPutAllThenCopyingSuccess(){
+        CopyingAHashMapToAnother obj = new CopyingAHashMapToAnother();
+        Assert.assertEquals(generateExpectedResultMap(), obj.copyUsingPutAll(generateSourceMap(), generateTargetMap()));
+    }
+
+    @Test
+    public void givenSourceAndTargetMapsWhenUsedPutIfAbsentThenCopyingSuccess(){
+        CopyingAHashMapToAnother obj = new CopyingAHashMapToAnother();
+        Assert.assertEquals(generateExpectedResultMap(), obj.copyUsingPutIfAbsent(generateSourceMap(), generateTargetMap()));
+        Assert.assertEquals(generateExpectedResultMap(), obj.copyUsingPutIfAbsentForEach(generateSourceMap(), generateTargetMap()));
+    }
+
+    @Test
+    public void givenSourceAndTargetMapsWhenUsedMapMergeThenCopyingSuccess(){
+        CopyingAHashMapToAnother obj = new CopyingAHashMapToAnother();
+        Assert.assertEquals(generateExpectedResultMap(), obj.copyUsingMapMerge(generateSourceMap(), generateTargetMap()));
+    }
+
+    @Test
+    public void givenSourceAndTargetMapsWhenMapDifferenceUsedThenCopyingSuccess(){
+        CopyingAHashMapToAnother obj = new CopyingAHashMapToAnother();
+        Assert.assertEquals(generateExpectedResultMap(), obj.copyUsingGuavaMapDifference(generateSourceMap(), generateTargetMap()));
+    }
+
+    private Map<String, String> generateSourceMap(){
+        Map<String, String> sourceMap = new HashMap<>();
+        sourceMap.put("India", "Delhi");
+        sourceMap.put("United States", "Washington D.C.");
+        sourceMap.put("United Kingdom", "London DC");
+        return sourceMap;
+    }
+
+    private Map<String, String> generateTargetMap(){
+        Map<String, String> targetMap = new HashMap<>();
+        targetMap.put("Zimbabwe", "Harare");
+        targetMap.put("Norway", "Oslo");
+        targetMap.put("United Kingdom", "London");
+        return targetMap;
+    }
+
+    private Map<String, String> generateExpectedResultMap(){
+        Map<String, String> resultMap = new HashMap<>();
+        resultMap.put("India", "Delhi");
+        resultMap.put("United States", "Washington D.C.");
+        resultMap.put("United Kingdom", "London");
+        resultMap.put("Zimbabwe", "Harare");
+        resultMap.put("Norway", "Oslo");
+        return resultMap;
+    }
+}

core-java-modules/core-java-concurrency-basic-3/pom.xml

@@ -24,4 +24,16 @@
         </resources>
     </build>
 
+    <properties>
+        <awaitility.version>4.2.0</awaitility.version>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.awaitility</groupId>
+            <artifactId>awaitility</artifactId>
+            <version>${awaitility.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 </project>

core-java-modules/core-java-concurrency-basic-3/src/main/java/com/baeldung/concurrent/RequestProcessor.java

@@ -0,0 +1,35 @@
+package com.baeldung.concurrent;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.UUID;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+public class RequestProcessor {
+
+    private Map<String, String> requestStatuses = new HashMap<>();
+
+    public String processRequest() {
+        String requestId = UUID.randomUUID().toString();
+        requestStatuses.put(requestId, "PROCESSING");
+
+        ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
+        executorService.schedule((() -> {
+            requestStatuses.put(requestId, "DONE");
+        }), getRandomNumberBetween(500, 2000), TimeUnit.MILLISECONDS);
+
+        return requestId;
+    }
+
+    public String getStatus(String requestId) {
+        return requestStatuses.get(requestId);
+    }
+
+    private int getRandomNumberBetween(int min, int max) {
+        Random random = new Random();
+        return random.nextInt(max - min) + min;
+    }
+}

core-java-modules/core-java-concurrency-basic-3/src/test/java/com/baeldung/concurrent/RequestProcessorUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.concurrent;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.not;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.concurrent.TimeUnit;
+
+import org.awaitility.Awaitility;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("Request processor")
+public class RequestProcessorUnitTest {
+
+    RequestProcessor requestProcessor = new RequestProcessor();
+
+    @Test
+    @DisplayName("Wait for completion using Thread.sleep")
+    void whenWaitingWithThreadSleep_thenStatusIsDone() throws InterruptedException {
+        String requestId = requestProcessor.processRequest();
+
+        Thread.sleep(2000);
+
+        assertEquals("DONE", requestProcessor.getStatus(requestId));
+    }
+
+    @Test
+    @DisplayName("Wait for completion using Awaitility")
+    void whenWaitingWithAwaitility_thenStatusIsDone() {
+        String requestId = requestProcessor.processRequest();
+
+        Awaitility.await()
+          .atMost(2, TimeUnit.SECONDS)
+          .pollDelay(500, TimeUnit.MILLISECONDS)
+          .until(() -> requestProcessor.getStatus(requestId), not(equalTo("PROCESSING")));
+
+        assertEquals("DONE", requestProcessor.getStatus(requestId));
+    }
+
+}

core-java-modules/core-java-functional/README.md

@@ -2,3 +2,4 @@
 
 - [Functional Programming in Java](https://www.baeldung.com/java-functional-programming)
 - [Functors in Java](https://www.baeldung.com/java-functors)
+- [Callback Functions in Java](https://www.baeldung.com/java-callback-functions)

core-java-modules/core-java-hex/README.md

@@ -0,0 +1,2 @@
+## Relevant Articles
+- [Convert Hex to RGB Using Java](https://www.baeldung.com/java-convert-hex-to-rgb)

core-java-modules/core-java-httpclient/README.md

@@ -5,3 +5,4 @@ This module contains articles about Java HttpClient
 ### Relevant articles
 - [Posting with Java HttpClient](https://www.baeldung.com/java-httpclient-post)
 - [Custom HTTP Header With the Java HttpClient](https://www.baeldung.com/java-http-client-custom-header)
+- [Java HttpClient Connection Management](https://www.baeldung.com/java-httpclient-connection-management)

core-java-modules/core-java-lang-oop-constructors/src/main/java/com/baeldung/reflection/PrivateConstructorClass.java

@@ -0,0 +1,8 @@
+package com.baeldung.reflection;
+
+public class PrivateConstructorClass {
+
+    private PrivateConstructorClass() {
+        System.out.println("Used the private constructor!");
+    }
+}

core-java-modules/core-java-lang-oop-constructors/src/test/java/com/baeldung/reflection/PrivateConstructorUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.reflection;
+
+import java.lang.reflect.Constructor;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class PrivateConstructorUnitTest {
+
+    @Test
+    public void whenConstructorIsPrivate_thenInstanceSuccess() throws Exception {
+        Constructor<PrivateConstructorClass> pcc = PrivateConstructorClass.class.getDeclaredConstructor();
+        pcc.setAccessible(true);
+        PrivateConstructorClass privateConstructorInstance = pcc.newInstance();
+        Assertions.assertTrue(privateConstructorInstance instanceof PrivateConstructorClass);
+    }
+}

core-java-modules/core-java-security-3/src/main/java/com/baeldung/crypto/exception/BadPaddingExamples.java

@@ -16,7 +16,7 @@ public class BadPaddingExamples {
         SecretKey encryptionKey = CryptoUtils.getKeyForText("BaeldungIsASuperCoolSite");
         SecretKey differentKey = CryptoUtils.getKeyForText("ThisGivesUsAnAlternative");
 
-        Cipher cipher = Cipher.getInstance("AES/ECB/ISO10126Padding");
+        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 
         cipher.init(Cipher.ENCRYPT_MODE, encryptionKey);
         byte[] cipherTextBytes = cipher.doFinal(plainTextBytes);
@@ -28,12 +28,12 @@ public class BadPaddingExamples {
 
     public static byte[] encryptAndDecryptUsingDifferentAlgorithms(SecretKey key, IvParameterSpec ivParameterSpec,
             byte[] plainTextBytes) throws InvalidKeyException, GeneralSecurityException {
-        Cipher cipher = Cipher.getInstance("AES/CBC/ISO10126Padding");
+        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
 
         cipher.init(Cipher.ENCRYPT_MODE, key, ivParameterSpec);
         byte[] cipherTextBytes = cipher.doFinal(plainTextBytes);
 
-        cipher = Cipher.getInstance("AES/ECB/ISO10126Padding");
+        cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
 
         cipher.init(Cipher.DECRYPT_MODE, key);
 

core-java-modules/core-java-security-algorithms/src/test/java/com/baeldung/aes/AESUtilUnitTest.java

@@ -48,7 +48,7 @@ class AESUtilUnitTest implements WithAssertions {
         IvParameterSpec ivParameterSpec = AESUtil.generateIv();
         File inputFile = Paths.get("src/test/resources/baeldung.txt")
             .toFile();
-        File encryptedFile = new File("classpath:baeldung.encrypted");
+        File encryptedFile = new File("baeldung.encrypted");
         File decryptedFile = new File("document.decrypted");
 
         // when
@@ -57,8 +57,8 @@ class AESUtilUnitTest implements WithAssertions {
 
         // then
         assertThat(inputFile).hasSameTextualContentAs(decryptedFile);
-        encryptedFile.delete();
-        decryptedFile.delete();
+        encryptedFile.deleteOnExit();
+        decryptedFile.deleteOnExit();
     }
 
     @Test

core-java-modules/core-java-streams-4/README.md

@@ -8,3 +8,4 @@
 - [Batch Processing of Stream Data in Java](https://www.baeldung.com/java-stream-batch-processing)
 - [Stream to Iterable in Java](https://www.baeldung.com/java-stream-to-iterable)
 - [Understanding the Difference Between Stream.of() and IntStream.range()](https://www.baeldung.com/java-stream-of-and-intstream-range)
+- [Check if Object Is an Array in Java](https://www.baeldung.com/java-check-if-object-is-an-array)

core-java-modules/core-java-streams-4/src/main/java/com/baeldung/streams/intarraytostrings/ArrayConversionUtils.java

@@ -0,0 +1,43 @@
+package com.baeldung.streams.intarraytostrings;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+public class ArrayConversionUtils {
+
+    public static void createStreamExample() {
+        int[] intArray = { 1, 2, 3, 4, 5 };
+        IntStream intStream = Arrays.stream(intArray);
+
+        Integer[] integerArray = { 1, 2, 3, 4, 5 };
+        Stream<Integer> integerStream = Arrays.stream(integerArray);
+    }
+
+    public static String[] convertToStringArray(Integer[] input) {
+        return Arrays.stream(input)
+          .map(Object::toString)
+          .toArray(String[]::new);
+    }
+
+    public static String[] convertToStringArray(int[] input) {
+        return Arrays.stream(input)
+          .mapToObj(Integer::toString)
+          .toArray(String[]::new);
+    }
+
+    public static String[] convertToStringArrayWithBoxing(int[] input) {
+        return Arrays.stream(input)
+          .boxed()
+          .map(Object::toString)
+          .toArray(String[]::new);
+    }
+
+    public static String convertToString(int[] input){
+        return Arrays.stream(input)
+          .mapToObj(Integer::toString)
+          .collect(Collectors.joining(", "));
+    }
+
+}

core-java-modules/core-java-streams-4/src/test/java/com/baeldung/streams/intarraytostrings/IntArrayToStringUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.streams.intarraytostrings;
+
+import static com.baeldung.streams.intarraytostrings.ArrayConversionUtils.convertToString;
+import static com.baeldung.streams.intarraytostrings.ArrayConversionUtils.convertToStringArray;
+import static com.baeldung.streams.intarraytostrings.ArrayConversionUtils.convertToStringArrayWithBoxing;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class IntArrayToStringUnitTest {
+
+    @Test
+    public void whenConvertingIntegers_thenHandleStreamOfIntegers() {
+        Integer[] integerNumbers = { 1, 2, 3, 4, 5 };
+        String[] expectedOutput = { "1", "2", "3", "4", "5" };
+
+        String[] strings = convertToStringArray(integerNumbers);
+
+        Assert.assertArrayEquals(expectedOutput, strings);
+    }
+
+    @Test
+    public void whenConvertingInts_thenHandleIntStream() {
+        int[] intNumbers = { 1, 2, 3, 4, 5 };
+        String[] expectedOutput = { "1", "2", "3", "4", "5" };
+
+        String[] strings = convertToStringArray(intNumbers);
+
+        Assert.assertArrayEquals(expectedOutput, strings);
+    }
+
+    @Test
+    public void givenAnIntArray_whenBoxingToInteger_thenHandleStreamOfIntegers() {
+        int[] intNumbers = { 1, 2, 3, 4, 5 };
+        String[] expectedOutput = { "1", "2", "3", "4", "5" };
+
+        String[] strings = convertToStringArrayWithBoxing(intNumbers);
+
+        Assert.assertArrayEquals(expectedOutput, strings);
+    }
+
+    @Test
+    public void givenAnIntArray_whenUsingCollectorsJoining_thenReturnCommaSeparatedString(){
+        int[] intNumbers = { 1, 2, 3, 4, 5 };
+        String expectedOutput = "1, 2, 3, 4, 5";
+
+        String string = convertToString(intNumbers);
+
+        Assert.assertEquals(expectedOutput, string);
+    }
+
+}

core-java-modules/core-java-string-algorithms-3/README.md

@@ -9,3 +9,4 @@ This module contains articles about string-related algorithms.
 - [Email Validation in Java](https://www.baeldung.com/java-email-validation-regex)
 - [Check if the First Letter of a String is Uppercase](https://www.baeldung.com/java-check-first-letter-uppercase)
 - [Find the First Non Repeating Character in a String in Java](https://www.baeldung.com/java-find-the-first-non-repeating-character)
+- [Find the First Embedded Occurrence of an Integer in a Java String](https://www.baeldung.com/java-string-find-embedded-integer)

core-java-modules/core-java/README.md

@@ -10,3 +10,4 @@
 - [Merging java.util.Properties Objects](https://www.baeldung.com/java-merging-properties)
 - [Illegal Character Compilation Error](https://www.baeldung.com/java-illegal-character-error)
 - [Lambda Expression vs. Anonymous Inner Class](https://www.baeldung.com/java-lambdas-vs-anonymous-class)
+- [Difference Between Class.forName() and Class.forName().newInstance()](https://www.baeldung.com/java-class-forname-vs-class-forname-newinstance)

core-java-modules/pom.xml

@@ -132,6 +132,7 @@
         <module>core-java-regex-2</module>
         <module>core-java-uuid</module>
         <module>pre-jpms</module>
+        <module>core-java-collections-maps-6</module>
     </modules>
 
     <dependencyManagement>

custom-pmd/pom.xml

@@ -44,10 +44,10 @@
     </build>
 
     <properties>
-        <maven-compiler-plugin.version>3.7.0</maven-compiler-plugin.version>
-        <pmdVersion>6.0.1</pmdVersion>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
+        <maven-compiler-plugin.version>3.10.0</maven-compiler-plugin.version>
+        <pmdVersion>6.53.0</pmdVersion>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
     </properties>
 
 </project>

custom-pmd/src/main/java/com/baeldung/pmd/UnitTestNamingConventionRule.java

@@ -18,8 +18,9 @@ public class UnitTestNamingConventionRule extends AbstractJavaRule {
       "UnitTest",
       "jmhTest");
 
+    @Override
     public Object visit(ASTClassOrInterfaceDeclaration node, Object data) {
-        String className = node.getImage();
+        String className = node.getSimpleName();
         Objects.requireNonNull(className);
 
         if (className.endsWith("SpringContextTest")) {

ddd/pom.xml

@@ -59,8 +59,8 @@
             <scope>runtime</scope>
         </dependency>
         <dependency>
-            <groupId>mysql</groupId>
-            <artifactId>mysql-connector-java</artifactId>
+            <groupId>com.mysql</groupId>
+            <artifactId>mysql-connector-j</artifactId>
             <scope>runtime</scope>
         </dependency>
         <dependency>

dependeny-exclusion/core-java-exclusions/pom.xml

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         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-exclusions</artifactId>
+    <version>0.0.0-SNAPSHOT</version>
+    <name>core-java-exclusions</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung.dependency-exclusion</groupId>
+        <artifactId>dependency-exclusion</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${surefire-version}</version>
+                <configuration>
+                    <runOrder>alphabetical</runOrder>
+                    <threadCount>1</threadCount>
+                    <properties>
+                        <property>
+                            <name>junit</name>
+                            <value>false</value>
+                        </property>
+                    </properties>
+                </configuration>
+                <dependencies>
+                    <dependency>
+                        <!-- Deactivate JUnit 4.7 engine by overriding it with an empty dummy -->
+                        <groupId>org.apache.maven.surefire</groupId>
+                        <artifactId>surefire-junit47</artifactId>
+                        <version>dummy</version>
+                    </dependency>
+                </dependencies>
+            </plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+</project>

dependeny-exclusion/core-java-exclusions/src/test/java/com/sample/project/tests/ExcludeDirectDependencyUnitTest.java

@@ -0,0 +1,12 @@
+package com.sample.project.tests;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class ExcludeDirectDependencyUnitTest {
+    @Test
+    public void basicUnitTest() {
+        assertTrue(true);
+    }
+}

dependeny-exclusion/dummy-surefire-junit47/pom.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         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>org.apache.maven.surefire</groupId>
+    <artifactId>surefire-junit47</artifactId>
+    <version>dummy</version>
+</project>

dependeny-exclusion/pom.xml

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         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.dependency-exclusion</groupId>
+    <artifactId>dependency-exclusion</artifactId>
+    <name>dependency-exclusion</name>
+    <packaging>pom</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../parent-java</relativePath>
+    </parent>
+
+    <properties>
+        <surefire-version>2.22.2</surefire-version>
+    </properties>
+
+    <modules>
+        <module>dummy-surefire-junit47</module>
+        <module>core-java-exclusions</module>
+    </modules>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-compiler-plugin</artifactId>
+                    <version>3.7.0</version>
+                    <configuration>
+                        <source>1.8</source>
+                        <target>1.8</target>
+                        <compilerArgs>
+                            <arg>-parameters</arg>
+                        </compilerArgs>
+                    </configuration>
+                </plugin>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-surefire-plugin</artifactId>
+                    <version>${surefire-version}</version>
+                    <configuration>
+                        <threadCount>1</threadCount>
+                    </configuration>
+                    <dependencies>
+                        <dependency>
+                            <groupId>org.apache.maven.surefire</groupId>
+                            <artifactId>surefire-junit-platform</artifactId>
+                            <version>${surefire-version}</version>
+                        </dependency>
+                    </dependencies>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>junit</groupId>
+                <artifactId>junit</artifactId>
+                <version>4.13</version>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+</project>

feign/README.md

@@ -7,3 +7,8 @@ This module contains articles about Feign
 - [Intro to Feign](https://www.baeldung.com/intro-to-feign)
 - [Retrying Feign Calls](https://www.baeldung.com/feign-retry)
 - [Setting Request Headers Using Feign](https://www.baeldung.com/java-feign-request-headers)
+- [File Upload With Open Feign](https://www.baeldung.com/java-feign-file-upload)
+- [Feign Logging Configuration](https://www.baeldung.com/java-feign-logging)
+- [Retrieve Original Message From Feign ErrorDecoder](https://www.baeldung.com/feign-retrieve-original-message)
+- [RequestLine with Feign Client](https://www.baeldung.com/feign-requestline)
+- [Propagating Exceptions With OpenFeign and Spring](https://www.baeldung.com/spring-openfeign-propagate-exception)

feign/pom.xml

@@ -64,6 +64,22 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.github.openfeign.form</groupId>
+            <artifactId>feign-form-spring</artifactId>
+            <version>${feign.form.spring.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-openfeign</artifactId>
+            <version>${spring.cloud.openfeign.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.tomakehurst</groupId>
+            <artifactId>wiremock-jre8</artifactId>
+            <version>${wire.mock.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -118,6 +134,9 @@
     <properties>
         <feign.version>11.8</feign.version>
         <wsdl4j.version>1.6.3</wsdl4j.version>
+        <feign.form.spring.version>3.8.0</feign.form.spring.version>
+        <spring.cloud.openfeign.version>3.1.2</spring.cloud.openfeign.version>
+        <wire.mock.version>2.33.2</wire.mock.version>
     </properties>
 
 </project>

feign/src/main/java/com/baeldung/core/ExampleApplication.java

@@ -0,0 +1,16 @@
+package com.baeldung.core;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+
+@SpringBootApplication
+@EnableFeignClients
+public class ExampleApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(ExampleApplication.class, args);
+    }
+
+}
+

feign/src/main/java/com/baeldung/core/client/EmployeeClient.java

@@ -1,6 +1,7 @@
-package com.baeldung.cloud.openfeign.client;
+package com.baeldung.core.client;
+
+import com.baeldung.core.model.Employee;
 
-import com.baeldung.cloud.openfeign.model.Employee;
 import feign.Headers;
 import feign.Param;
 import feign.RequestLine;

feign/src/main/java/com/baeldung/core/client/UserClient.java

@@ -0,0 +1,13 @@
+package com.baeldung.core.client;
+
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.GetMapping;
+
+import com.baeldung.core.config.FeignConfig;
+
+@FeignClient(name = "user-client", url="https://jsonplaceholder.typicode.com", configuration = FeignConfig.class)
+public interface UserClient {
+
+	@GetMapping(value = "/users")
+	String getUsers();
+}

feign/src/main/java/com/baeldung/core/config/FeignConfig.java

@@ -1,7 +1,8 @@
-package com.baeldung.cloud.openfeign.config;
+package com.baeldung.core.config;
+
+import org.springframework.context.annotation.Bean;
 
 import feign.Logger;
-import org.springframework.context.annotation.Bean;
 
 public class FeignConfig {
 

feign/src/main/java/com/baeldung/core/controller/EmployeeController.java

@@ -1,13 +1,15 @@
-package com.baeldung.cloud.openfeign.controller;
+package com.baeldung.core.controller;
 
-import com.baeldung.cloud.openfeign.client.EmployeeClient;
-import com.baeldung.cloud.openfeign.model.Employee;
-import feign.Feign;
-import feign.form.spring.SpringFormEncoder;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
+import com.baeldung.core.client.EmployeeClient;
+import com.baeldung.core.model.Employee;
+
+import feign.Feign;
+import feign.form.spring.SpringFormEncoder;
+
 @RestController
 public class EmployeeController {
 

feign/src/main/java/com/baeldung/core/customizederrorhandling/client/ProductClient.java

@@ -1,13 +1,13 @@
-package com.baeldung.cloud.openfeign.customizederrorhandling.client;
-
-import com.baeldung.cloud.openfeign.customizederrorhandling.config.FeignConfig;
-import com.baeldung.cloud.openfeign.defaulterrorhandling.model.Product;
+package com.baeldung.core.customizederrorhandling.client;
 
 import org.springframework.cloud.openfeign.FeignClient;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 
+import com.baeldung.core.customizederrorhandling.config.FeignConfig;
+import com.baeldung.core.defaulterrorhandling.model.Product;
+
 @FeignClient(name = "product-client-2", url = "http://localhost:8081/product/", configuration = FeignConfig.class)
 public interface ProductClient {
 

feign/src/main/java/com/baeldung/core/customizederrorhandling/config/CustomErrorDecoder.java

@@ -1,8 +1,9 @@
-package com.baeldung.cloud.openfeign.customizederrorhandling.config;
+package com.baeldung.core.customizederrorhandling.config;
+
+import com.baeldung.core.customizederrorhandling.exception.ProductNotFoundException;
+import com.baeldung.core.customizederrorhandling.exception.ProductServiceNotAvailableException;
+import com.baeldung.core.exception.BadRequestException;
 
-import com.baeldung.cloud.openfeign.exception.BadRequestException;
-import com.baeldung.cloud.openfeign.customizederrorhandling.exception.ProductNotFoundException;
-import com.baeldung.cloud.openfeign.customizederrorhandling.exception.ProductServiceNotAvailableException;
 import feign.Response;
 import feign.codec.ErrorDecoder;
 

feign/src/main/java/com/baeldung/core/customizederrorhandling/config/FeignConfig.java

@@ -1,8 +1,9 @@
-package com.baeldung.cloud.openfeign.customizederrorhandling.config;
+package com.baeldung.core.customizederrorhandling.config;
+
+import org.springframework.context.annotation.Bean;
 
 import feign.Logger;
 import feign.codec.ErrorDecoder;
-import org.springframework.context.annotation.Bean;
 
 public class FeignConfig {
 

feign/src/main/java/com/baeldung/core/customizederrorhandling/controller/ProductController.java

@@ -1,12 +1,13 @@
-package com.baeldung.cloud.openfeign.customizederrorhandling.controller;
+package com.baeldung.core.customizederrorhandling.controller;
 
-import com.baeldung.cloud.openfeign.customizederrorhandling.client.ProductClient;
-
-
-import com.baeldung.cloud.openfeign.defaulterrorhandling.model.Product;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.*;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
 
+import com.baeldung.core.customizederrorhandling.client.ProductClient;
+import com.baeldung.core.defaulterrorhandling.model.Product;
 
 @RestController("product_controller2")
 @RequestMapping(value = "myapp2")

feign/src/main/java/com/baeldung/core/customizederrorhandling/exception/ErrorResponse.java

@@ -1,10 +1,11 @@
-package com.baeldung.cloud.openfeign.customizederrorhandling.exception;
+package com.baeldung.core.customizederrorhandling.exception;
+
+import java.util.Date;
+
+import org.springframework.http.HttpStatus;
 
 import com.fasterxml.jackson.annotation.JsonFormat;
 import com.fasterxml.jackson.annotation.JsonProperty;
-import org.springframework.http.HttpStatus;
-
-import java.util.Date;
 
 public class ErrorResponse {
 

feign/src/main/java/com/baeldung/core/customizederrorhandling/exception/ProductExceptionHandler.java

@@ -1,6 +1,5 @@
-package com.baeldung.cloud.openfeign.customizederrorhandling.exception;
+package com.baeldung.core.customizederrorhandling.exception;
 
-import com.baeldung.cloud.openfeign.exception.BadRequestException;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.ExceptionHandler;

feign/src/main/java/com/baeldung/core/customizederrorhandling/exception/ProductNotFoundException.java

@@ -1,4 +1,4 @@
-package com.baeldung.cloud.openfeign.customizederrorhandling.exception;
+package com.baeldung.core.customizederrorhandling.exception;
 
 public class ProductNotFoundException extends RuntimeException {
 

feign/src/main/java/com/baeldung/core/customizederrorhandling/exception/ProductServiceNotAvailableException.java

@@ -1,4 +1,4 @@
-package com.baeldung.cloud.openfeign.customizederrorhandling.exception;
+package com.baeldung.core.customizederrorhandling.exception;
 
 public class ProductServiceNotAvailableException extends RuntimeException {