Merge branch 'eugenp:master' into master

.gitignore

@@ -107,4 +107,11 @@ spring-boot-modules/spring-boot-properties-3/*.log
 .sdkmanrc
 
 # Localstack
-**/.localstack
+**/.localstack
+
+#libraries-2
+libraries-2/employee*
+libraries-2/src/test/resources/crawler4j/**
+
+#web-modules/ninja
+devDb*.db

apache-cxf-modules/cxf-introduction/pom.xml

@@ -23,6 +23,16 @@
             <artifactId>cxf-rt-transports-http-jetty</artifactId>
             <version>${cxf.version}</version>
         </dependency>
+        <dependency>
+            <groupId>jakarta.xml.ws</groupId>
+            <artifactId>jakarta.xml.ws-api</artifactId>
+            <version>${jakarta-xml.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.jws</groupId>
+            <artifactId>jakarta.jws-api</artifactId>
+            <version>${jakarta.jws.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -37,4 +47,10 @@
         </plugins>
     </build>
 
+    <properties>
+        <cxf.version>4.0.0</cxf.version>
+        <jakarta-xml.version>4.0.0</jakarta-xml.version>
+        <jakarta.jws.version>3.0.0</jakarta.jws.version>
+    </properties>
+
 </project>

apache-cxf-modules/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/Baeldung.java

@@ -2,8 +2,8 @@ package com.baeldung.cxf.introduction;
 
 import java.util.Map;
 
-import javax.jws.WebService;
+import jakarta.jws.WebService;
-import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
 @WebService
 public interface Baeldung {

apache-cxf-modules/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/BaeldungImpl.java

@@ -3,7 +3,7 @@ package com.baeldung.cxf.introduction;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-import javax.jws.WebService;
+import jakarta.jws.WebService;
 
 @WebService(endpointInterface = "com.baeldung.cxf.introduction.Baeldung")
 public class BaeldungImpl implements Baeldung {

apache-cxf-modules/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/Server.java

@@ -1,6 +1,6 @@
 package com.baeldung.cxf.introduction;
 
-import javax.xml.ws.Endpoint;
+import jakarta.xml.ws.Endpoint;
 
 public class Server {
     public static void main(String args[]) throws InterruptedException {

apache-cxf-modules/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/Student.java

@@ -1,6 +1,6 @@
 package com.baeldung.cxf.introduction;
 
-import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
+import jakarta.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
 
 @XmlJavaTypeAdapter(StudentAdapter.class)
 public interface Student {

apache-cxf-modules/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/StudentAdapter.java

@@ -1,6 +1,6 @@
 package com.baeldung.cxf.introduction;
 
-import javax.xml.bind.annotation.adapters.XmlAdapter;
+import jakarta.xml.bind.annotation.adapters.XmlAdapter;
 
 public class StudentAdapter extends XmlAdapter<StudentImpl, Student> {
     public StudentImpl marshal(Student student) throws Exception {

apache-cxf-modules/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/StudentImpl.java

@@ -1,6 +1,6 @@
 package com.baeldung.cxf.introduction;
 
-import javax.xml.bind.annotation.XmlType;
+import jakarta.xml.bind.annotation.XmlType;
 
 @XmlType(name = "Student")
 public class StudentImpl implements Student {

apache-cxf-modules/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/StudentMap.java

@@ -3,8 +3,8 @@ package com.baeldung.cxf.introduction;
 import java.util.ArrayList;
 import java.util.List;
 
-import javax.xml.bind.annotation.XmlElement;
+import jakarta.xml.bind.annotation.XmlElement;
-import javax.xml.bind.annotation.XmlType;
+import jakarta.xml.bind.annotation.XmlType;
 
 @XmlType(name = "StudentMap")
 public class StudentMap {

apache-cxf-modules/cxf-introduction/src/main/java/com/baeldung/cxf/introduction/StudentMapAdapter.java

@@ -3,7 +3,7 @@ package com.baeldung.cxf.introduction;
 import java.util.LinkedHashMap;
 import java.util.Map;
 
-import javax.xml.bind.annotation.adapters.XmlAdapter;
+import jakarta.xml.bind.annotation.adapters.XmlAdapter;
 
 public class StudentMapAdapter extends XmlAdapter<StudentMap, Map<Integer, Student>> {
     public StudentMap marshal(Map<Integer, Student> boundMap) throws Exception {

apache-cxf-modules/cxf-introduction/src/test/java/com/baeldung/cxf/introduction/StudentLiveTest.java

@@ -5,8 +5,8 @@ import static org.junit.Assert.assertEquals;
 import java.util.Map;
 
 import javax.xml.namespace.QName;
-import javax.xml.ws.Service;
+import jakarta.xml.ws.Service;
-import javax.xml.ws.soap.SOAPBinding;
+import jakarta.xml.ws.soap.SOAPBinding;
 
 import org.junit.Before;
 import org.junit.Test;

apache-cxf-modules/cxf-jaxrs-implementation/pom.xml

@@ -16,12 +16,28 @@
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-frontend-jaxrs</artifactId>
-            <version>${cxf.version}</version>
+            <version>4.0.0</version>
         </dependency>
         <dependency>
             <groupId>org.apache.cxf</groupId>
             <artifactId>cxf-rt-transports-http-jetty</artifactId>
-            <version>${cxf.version}</version>
+            <version>4.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.xml.ws</groupId>
+            <artifactId>jakarta.xml.ws-api</artifactId>
+            <version>${jakarta-xml.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.jws</groupId>
+            <artifactId>jakarta.jws-api</artifactId>
+            <version>${jakarta-jws.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>jakarta.platform</groupId>
+            <artifactId>jakarta.jakartaee-web-api</artifactId>
+            <version>${jakarta-platform.version}</version>
+            <scope>compile</scope>
         </dependency>
         <dependency>
             <groupId>org.apache.httpcomponents</groupId>
@@ -50,6 +66,9 @@
 
     <properties>
         <httpclient.version>4.5.2</httpclient.version>
+        <jakarta-xml.version>4.0.0</jakarta-xml.version>
+        <jakarta-jws.version>3.0.0</jakarta-jws.version>
+        <jakarta-platform.version>9.0.0</jakarta-platform.version>
     </properties>
 
 </project>

apache-cxf-modules/cxf-jaxrs-implementation/src/main/java/com/baeldung/cxf/jaxrs/implementation/Course.java

@@ -1,8 +1,8 @@
 package com.baeldung.cxf.jaxrs.implementation;
 
-import javax.ws.rs.*;
+import jakarta.ws.rs.*;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
-import javax.xml.bind.annotation.XmlRootElement;
+import jakarta.xml.bind.annotation.XmlRootElement;
 
 import java.util.ArrayList;
 import java.util.List;

apache-cxf-modules/cxf-jaxrs-implementation/src/main/java/com/baeldung/cxf/jaxrs/implementation/CourseRepository.java

@@ -1,7 +1,7 @@
 package com.baeldung.cxf.jaxrs.implementation;
 
-import javax.ws.rs.*;
+import jakarta.ws.rs.*;
-import javax.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;

apache-cxf-modules/cxf-jaxrs-implementation/src/main/java/com/baeldung/cxf/jaxrs/implementation/Student.java

@@ -1,6 +1,6 @@
 package com.baeldung.cxf.jaxrs.implementation;
 
-import javax.xml.bind.annotation.XmlRootElement;
+import jakarta.xml.bind.annotation.XmlRootElement;
 
 @XmlRootElement(name = "Student")
 public class Student {

apache-cxf-modules/cxf-jaxrs-implementation/src/test/java/com/baeldung/cxf/jaxrs/implementation/ServiceLiveTest.java

@@ -7,7 +7,7 @@ import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.net.URL;
 
-import javax.xml.bind.JAXB;
+import jakarta.xml.bind.JAXB;
 
 import org.apache.http.HttpResponse;
 import org.apache.http.client.methods.HttpDelete;

apache-cxf-modules/cxf-spring/pom.xml

@@ -40,10 +40,22 @@
             <artifactId>spring-webmvc</artifactId>
             <version>${spring.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.sun.xml.ws</groupId>
+            <artifactId>jaxws-ri</artifactId>
+            <version>2.3.3</version>
+            <type>pom</type>
+        </dependency>
         <dependency>
             <groupId>javax.servlet</groupId>
             <artifactId>javax.servlet-api</artifactId>
-            <version>${javax.servlet-api.version}</version>
+            <version>4.0.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>jstl</artifactId>
+            <version>1.2</version>
         </dependency>
     </dependencies>
 
@@ -103,8 +115,9 @@
     </profiles>
 
     <properties>
-        <spring.version>4.3.4.RELEASE</spring.version>
+        <spring.version>5.3.25</spring.version>
         <cargo-maven2-plugin.version>1.6.1</cargo-maven2-plugin.version>
+        <maven-war-plugin.version>3.3.2</maven-war-plugin.version>
     </properties>
 
 </project>

apache-cxf-modules/sse-jaxrs/sse-jaxrs-client/pom.xml

@@ -23,6 +23,11 @@
             <artifactId>cxf-rt-rs-sse</artifactId>
             <version>${cxf-version}</version>
         </dependency>
+        <dependency>
+            <groupId>jakarta.ws.rs</groupId>
+            <artifactId>jakarta.ws.rs-api</artifactId>
+            <version>${jakarta-ws.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -55,7 +60,8 @@
     </build>
 
     <properties>
-        <cxf-version>3.2.0</cxf-version>
+        <cxf-version>4.0.0</cxf-version>
+        <jakarta-ws.version>3.1.0</jakarta-ws.version>
     </properties>
 
 </project>

apache-cxf-modules/sse-jaxrs/sse-jaxrs-client/src/main/java/com/baeldung/sse/jaxrs/client/SseClientApp.java

@@ -1,10 +1,10 @@
 package com.baeldung.sse.jaxrs.client;
 
-import javax.ws.rs.client.Client;
+import jakarta.ws.rs.client.Client;
-import javax.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.client.ClientBuilder;
-import javax.ws.rs.client.WebTarget;
+import jakarta.ws.rs.client.WebTarget;
-import javax.ws.rs.sse.InboundSseEvent;
+import jakarta.ws.rs.sse.InboundSseEvent;
-import javax.ws.rs.sse.SseEventSource;
+import jakarta.ws.rs.sse.SseEventSource;
 import java.util.function.Consumer;
 
 public class SseClientApp {

apache-cxf-modules/sse-jaxrs/sse-jaxrs-client/src/main/java/com/baeldung/sse/jaxrs/client/SseClientBroadcastApp.java

@@ -1,10 +1,10 @@
 package com.baeldung.sse.jaxrs.client;
 
-import javax.ws.rs.client.Client;
+import jakarta.ws.rs.client.Client;
-import javax.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.client.ClientBuilder;
-import javax.ws.rs.client.WebTarget;
+import jakarta.ws.rs.client.WebTarget;
-import javax.ws.rs.sse.InboundSseEvent;
+import jakarta.ws.rs.sse.InboundSseEvent;
-import javax.ws.rs.sse.SseEventSource;
+import jakarta.ws.rs.sse.SseEventSource;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
 

apache-cxf-modules/sse-jaxrs/sse-jaxrs-server/pom.xml

@@ -15,16 +15,14 @@
 
     <dependencies>
         <dependency>
-            <groupId>javax.ws.rs</groupId>
+            <groupId>jakarta.ws.rs</groupId>
-            <artifactId>javax.ws.rs-api</artifactId>
+            <artifactId>jakarta.ws.rs-api</artifactId>
-            <version>${rs-api.version}</version>
+            <version>${jakarta-ws.version}</version>
-            <scope>provided</scope>
         </dependency>
         <dependency>
-            <groupId>javax.enterprise</groupId>
+            <groupId>jakarta.enterprise</groupId>
-            <artifactId>cdi-api</artifactId>
+            <artifactId>jakarta.enterprise.cdi-api</artifactId>
-            <version>${cdi-api.version}</version>
+            <version>${jakarta-cdi-api}</version>
-            <scope>provided</scope>
         </dependency>
         <dependency>
             <groupId>javax.json.bind</groupId>
@@ -37,6 +35,11 @@
     <build>
         <finalName>${project.artifactId}</finalName>
         <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-war-plugin</artifactId>
+                <version>${maven-war-plugin.version}</version>
+            </plugin>
             <plugin>
                 <groupId>net.wasdev.wlp.maven.plugins</groupId>
                 <artifactId>liberty-maven-plugin</artifactId>
@@ -78,9 +81,10 @@
         <liberty-maven-plugin.version>2.4.2</liberty-maven-plugin.version>
         <failOnMissingWebXml>false</failOnMissingWebXml>
         <openliberty-version>18.0.0.2</openliberty-version>
-        <rs-api.version>2.1</rs-api.version>
+        <jakarta-ws.version>3.1.0</jakarta-ws.version>
-        <cdi-api.version>2.0</cdi-api.version>
+        <jakarta-cdi-api>4.0.1</jakarta-cdi-api>
         <bind-api.version>1.0</bind-api.version>
+        <maven-war-plugin.version>3.3.2</maven-war-plugin.version>
     </properties>
 
 </project>

apache-cxf-modules/sse-jaxrs/sse-jaxrs-server/src/main/java/com/baeldung/sse/jaxrs/AppConfig.java

@@ -1,7 +1,7 @@
 package com.baeldung.sse.jaxrs;
 
-import javax.ws.rs.ApplicationPath;
+import jakarta.ws.rs.ApplicationPath;
-import javax.ws.rs.core.Application;
+import jakarta.ws.rs.core.Application;
 
 @ApplicationPath("sse")
 public class AppConfig extends Application {

apache-cxf-modules/sse-jaxrs/sse-jaxrs-server/src/main/java/com/baeldung/sse/jaxrs/SseResource.java

@@ -1,15 +1,15 @@
 package com.baeldung.sse.jaxrs;
 
-import javax.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.context.ApplicationScoped;
-import javax.inject.Inject;
+import jakarta.inject.Inject;
-import javax.ws.rs.*;
+import jakarta.ws.rs.*;
-import javax.ws.rs.core.Context;
+import jakarta.ws.rs.core.Context;
-import javax.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.MediaType;
-import javax.ws.rs.sse.OutboundSseEvent;
+import jakarta.ws.rs.sse.OutboundSseEvent;
-import javax.ws.rs.sse.Sse;
+import jakarta.ws.rs.sse.Sse;
-import javax.ws.rs.sse.SseBroadcaster;
+import jakarta.ws.rs.sse.SseBroadcaster;
-import javax.ws.rs.sse.SseEventSink;
+import jakarta.ws.rs.sse.SseEventSink;
 
 @ApplicationScoped
 @Path("stock")

apache-cxf-modules/sse-jaxrs/sse-jaxrs-server/src/main/java/com/baeldung/sse/jaxrs/StockService.java

@@ -1,11 +1,11 @@
 package com.baeldung.sse.jaxrs;
 
-import javax.enterprise.context.ApplicationScoped;
+import jakarta.enterprise.context.ApplicationScoped;
-import javax.enterprise.context.Initialized;
+import jakarta.enterprise.context.Initialized;
-import javax.enterprise.event.Event;
+import jakarta.enterprise.event.Event;
-import javax.enterprise.event.Observes;
+import jakarta.enterprise.event.Observes;
-import javax.inject.Inject;
+import jakarta.inject.Inject;
-import javax.inject.Named;
+import jakarta.inject.Named;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.time.LocalDateTime;

apache-httpclient4/README.md

@@ -1,4 +1,4 @@
-## Apache HttpClient
+## Apache HttpClient 4
 
 This module contains articles about Apache HttpClient 4.5
 

apache-httpclient4/pom.xml

@@ -3,9 +3,9 @@
          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>httpclient4</artifactId>
+    <artifactId>apache-httpclient4</artifactId>
     <version>0.1-SNAPSHOT</version>
-    <name>httpclient4</name>
+    <name>apache-httpclient4</name>
     <packaging>war</packaging>
 
     <parent>

apache-libraries/pom.xml

@@ -118,11 +118,6 @@
             <artifactId>curator-recipes</artifactId>
             <version>${curator.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.apache.zookeeper</groupId>
-            <artifactId>zookeeper</artifactId>
-            <version>${zookeeper.version}</version>
-        </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-core</artifactId>
@@ -191,10 +186,8 @@
     </build>
 
     <properties>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
         <avro.version>1.8.2</avro.version>
-        <beam.version>2.19.0</beam.version>
+        <beam.version>2.45.0</beam.version>
         <bval.version>1.1.2</bval.version>
         <javax.validation.validation-api.version>1.1.0.Final</javax.validation.validation-api.version>
         <meecrowave-junit.version>1.2.0</meecrowave-junit.version>

core-groovy-modules/core-groovy-2/README.md

@@ -14,4 +14,4 @@ This module contains articles about core Groovy concepts
 - [A Quick Guide to Working with Web Services in Groovy](https://www.baeldung.com/groovy-web-services)
 - [Categories in Groovy](https://www.baeldung.com/groovy-categories)
 - [How to Determine the Data Type in Groovy](https://www.baeldung.com/groovy-determine-data-type)
-- [[<-- Prev]](/core-groovy)
+- [[<-- Prev]](/core-groovy-modules/core-groovy)

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

@@ -83,7 +83,7 @@
                     <dependency>
                         <groupId>org.codehaus.groovy</groupId>
                         <artifactId>groovy-eclipse-batch</artifactId>
-                        <version>${groovy.version}-01</version>
+                        <version>${groovy-eclipse-batch.version}</version>
                     </dependency>
                 </dependencies>
             </plugin>
@@ -155,16 +155,18 @@
 
     <repositories>
         <repository>
-            <id>central</id>
+            <id>maven_central</id>
-            <url>https://jcenter.bintray.com</url>
+            <name>Maven Central</name>
+            <url>https://repo.maven.apache.org/maven2/</url>
         </repository>
     </repositories>
 
     <properties>
         <groovy-wslite.version>1.1.3</groovy-wslite.version>
-        <assembly.plugin.version>3.1.0</assembly.plugin.version>
+        <assembly.plugin.version>3.4.2</assembly.plugin.version>
-        <compiler.plugin.version>3.8.0</compiler.plugin.version>
+        <compiler.plugin.version>3.8.1</compiler.plugin.version>
-        <groovy.compiler.version>3.3.0-01</groovy.compiler.version>
+        <groovy.compiler.version>3.7.0</groovy.compiler.version>
+        <groovy-eclipse-batch.version>3.0.8-01</groovy-eclipse-batch.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) {
+    static String capitalize(String self) {
-        String capitalizedStr = 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;
+package com.baeldung.category
-
-import groovy.lang.Category
 
 @Category(Number)
 class NumberCategory {
 
-    public Number cube() {
+    Number cube() {
-        return this*this*this
+        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
+    int ageAsInt
-    private Double ageAsDouble
+    Double ageAsDouble
-    private String ageAsString
+    String ageAsString
-    
+
     Person() {}
-    Person(int ageAsInt) { this.ageAsInt =  ageAsInt}
+
-    Person(Double ageAsDouble) { this.ageAsDouble =  ageAsDouble}
+    Person(int ageAsInt) { this.ageAsInt = ageAsInt }
-    Person(String ageAsString) { this.ageAsString =  ageAsString}    
+
+    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.*
-import groovy.transform.Canonical
+import groovy.util.logging.Log
-import groovy.transform.EqualsAndHashCode
-import groovy.transform.ToString
-import groovy.transform.TupleConstructor
-import groovy.util.logging.*
 
-@Canonical
+@ToString(includePackage = false, excludes = ['id'])
 @TupleConstructor
 @EqualsAndHashCode
-@ToString(includePackage=false, excludes=['id'])
+@Canonical
-@Log 
+@AutoClone(style = AutoCloneStyle.SIMPLE)
-@AutoClone
+@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 spock.lang.Specification
-import org.junit.Test
-import com.baeldung.determinedatatype.Person
 
-public class PersonTest {
+class PersonTest extends Specification {
-    
+
-    @Test
+    def "givenWhenParameterTypeIsIntegerThenReturnTrue"() {
-    public void givenWhenParameterTypeIsInteger_thenReturnTrue() {
+        given:
         Person personObj = new Person(10)
-        Assert.assertTrue(personObj.ageAsInt instanceof Integer)
+
-    }
+        expect:
-    
+        personObj.ageAsInt.class == 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)
     }
 
-    @Test
+    def "givenWhenParameterTypeIsDouble_thenReturnTrue"() {
-    public void givenWhenInstanceIsOfSubtype_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
+    def "givenGroovyList_WhenFindClassName_thenReturnTrue"() {
-    public void givenGroovyList_WhenFindClassName_thenReturnTrue() {
+        given:
-      def ageList = ['ageAsString','ageAsDouble', 10]   
+        def ageList = ['ageAsString', 'ageAsDouble', 10]
-      Assert.assertTrue(ageList.class == ArrayList)     
+
-      Assert.assertTrue(ageList.getClass() == ArrayList)
+        expect:
+        ageList.class == ArrayList
+        ageList.getClass() == ArrayList
     }
-    
+
-    @Test
+    def "givenGroovyMap_WhenFindClassName_thenReturnTrue"() {
-    public void givenGrooyMap_WhenFindClassName_thenReturnTrue() {
+        given:
-      def ageMap = [ageAsString: '10 years', ageAsDouble: 10.0]
+        def ageMap = [ageAsString: '10 years', ageAsDouble: 10.0]
-      Assert.assertFalse(ageMap.class == LinkedHashMap)
+
+        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() {
+    void setup() {
-        assert emp.address == "property 'address' is not available"
+        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()
+        expect:
-        } catch(MissingMethodException e) {
+        emp.getFullName() == "method 'getFullName' is not defined"
-            println "method is not defined"
-        }
-        assert 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() {
+    def "testOnlyNameConstructor"() {
-        try {
+        when:
-            Employee emp = new Employee("Norman")
+        new Employee("Norman")
-        } catch(GroovyRuntimeException e) {
-            assert e.message == "Could not find matching constructor for: com.baeldung.metaprogramming.Employee(String)"
-        }
 
+        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
+        then:
-
+        40L.square() == 1600L
-        assert (2.98).cube() == 26.463592
+        (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() {
+    def "testToStringAnnotation"() {
-        Employee employee = new Employee()
+        when:
-        employee.id = 1
+        Employee employee = new Employee().tap {
-        employee.firstName = "norman"
+            id = 1
-        employee.lastName = "lewis"
+            firstName = "norman"
-        employee.age = 28
+            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()
+        then:
-    }
+        norman == normanCopy
-    
+        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()
-        }
     }
 
-    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 {
+class TemplateEnginesUnitTest extends Specification {
-    
+
-    def bindMap = [user: "Norman", signature: "Baeldung"]
+    final Map BIND_MAP = [user: "Norman", signature: "Baeldung"]
-    
+
-    void testSimpleTemplateEngine() {
+    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
+        //can be a string larger than 64k
-This is a tutorial article on Template Engines""" //can be a string larger than 64k
+        BIND_MAP.articleText = """|1. Overview
-        
+                                  |This is a tutorial article on Template Engines""".stripMargin()
-        def articleEmailText = new StreamingTemplateEngine().createTemplate(articleEmailTemplate).make(bindMap)
+
-        
+        when:
-        assert articleEmailText.toString() == """Dear Norman,
+        def articleEmailText = new StreamingTemplateEngine().createTemplate(articleEmailTemplate).make(BIND_MAP)
-Please read the requested article below.
+
-1. Overview
+        then:
-This is a tutorial article on Template Engines
+        articleEmailText.toString() == """|Dear Norman,
-From,
+                                          |Please read the requested article below.
-Baeldung"""
+                                          |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)
+
-        
+        when:
-        assert emailText.toString() == "Dear Norman,\nThanks for subscribing our services.\nBaeldung"
+        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()
+        TemplateConfiguration config = new TemplateConfiguration().with {
-        config.autoIndent = true
+            autoIndent = true
-        config.autoEscape = true
+            autoEscape = true
-        config.autoNewLine = 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>
+            <id>maven_central</id>
-            <url>http://jcenter.bintray.com</url>
+            <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 spock.lang.Specification
-import org.junit.Test
 
-import static org.junit.Assert.*
+class ListFindUnitTest extends Specification {
 
-class ListFindUnitTest {
+    final personList = [
-
+            new Person("Regina", "Fitzpatrick", 25),
-    private final personList = [
+            new Person("Abagail", "Ballard", 26),
-      new Person("Regina", "Fitzpatrick", 25),
+            new Person("Lucian", "Walter", 30),
-      new Person("Abagail", "Ballard", 26),
-      new Person("Lucian", "Walter", 30),
     ]
 
-    @Test
+    def "whenListContainsElement_thenCheckReturnsTrue"() {
-    void whenListContainsElement_thenCheckReturnsTrue() {
+        given:
         def list = ['a', 'b', 'c']
 
-        assertTrue(list.indexOf('a') > -1)
+        expect:
-        assertTrue(list.contains('a'))
+        list.indexOf('a') > -1
+        list.contains('a')
     }
 
-    @Test
+    def "whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue"() {
-    void whenListContainsElement_thenCheckWithMembershipOperatorReturnsTrue() {
+        given:
         def list = ['a', 'b', 'c']
 
-        assertTrue('a' in list)
+        expect:
+        'a' in list
     }
 
-    @Test
+    def "givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList"() {
-    void givenListOfPerson_whenUsingStreamMatching_thenShouldEvaluateList() {
+        expect:
-        assertTrue(personList.stream().anyMatch {it.age > 20})
+        personList.stream().anyMatch { it.age > 20 }
-        assertFalse(personList.stream().allMatch {it.age < 30})
+        !personList.stream().allMatch { it.age < 30 }
     }
 
-    @Test
+    def "givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList"() {
-    void givenListOfPerson_whenUsingCollectionMatching_thenShouldEvaluateList() {
+        expect:
-        assertTrue(personList.any {it.age > 20})
+        personList.any { it.age > 20 }
-        assertFalse(personList.every {it.age < 30})
+        !personList.every { it.age < 30 }
     }
 
-    @Test
+    def "givenListOfPerson_whenUsingStreamFind_thenShouldReturnMatchingElements"() {
-    void givenListOfPerson_whenUsingStreamFind_thenShouldReturnMatchingElements() {
+        expect:
-        assertTrue(personList.stream().filter {it.age > 20}.findAny().isPresent())
+        personList.stream().filter { it.age > 20 }.findAny().isPresent()
-        assertFalse(personList.stream().filter {it.age > 30}.findAny().isPresent())
+        !personList.stream().filter { it.age > 30 }.findAny().isPresent()
-        assertTrue(personList.stream().filter {it.age > 20}.findAll().size() == 3)
+        personList.stream().filter { it.age > 20 }.findAll().size() == 3
-        assertTrue(personList.stream().filter {it.age > 30}.findAll().isEmpty())
+        personList.stream().filter { it.age > 30 }.findAll().isEmpty()
     }
 
-    @Test
+    def "givenListOfPerson_whenUsingCollectionFind_thenShouldReturnMatchingElements"() {
-    void givenListOfPerson_whenUsingCollectionFind_thenShouldReturnMatchingElements() {
+        expect:
-        assertNotNull(personList.find {it.age > 20})
+        personList.find { it.age > 20 } == new Person("Regina", "Fitzpatrick", 25)
-        assertNull(personList.find {it.age > 30})
+        personList.find { it.age > 30 } == null
-        assertTrue(personList.findAll {it.age > 20}.size() == 3)
+        personList.findAll { it.age > 20 }.size() == 3
-        assertTrue(personList.findAll {it.age > 30}.isEmpty())
+        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 spock.lang.Specification
-import org.junit.Test
 
-import static org.junit.Assert.*
+class MapFindUnitTest extends Specification {
 
-class MapFindUnitTest {
+    final personMap = [
-
+            Regina: new Person("Regina", "Fitzpatrick", 25),
-    private final personMap = [
+            Abagail: new Person("Abagail", "Ballard", 26),
-      Regina : new Person("Regina", "Fitzpatrick", 25),
+            Lucian: new Person("Lucian", "Walter", 30)
-      Abagail: new Person("Abagail", "Ballard", 26),
-      Lucian : new Person("Lucian", "Walter", 30)
     ]
 
-    @Test
+    def "whenMapContainsKeyElement_thenCheckReturnsTrue"() {
-    void whenMapContainsKeyElement_thenCheckReturnsTrue() {
+        given:
         def map = [a: 'd', b: 'e', c: 'f']
 
-        assertTrue(map.containsKey('a'))
+        expect:
-        assertFalse(map.containsKey('e'))
+        map.containsKey('a')
-        assertTrue(map.containsValue('e'))
+        !map.containsKey('e')
+        map.containsValue('e')
     }
 
-    @Test
+    def "whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue"() {
-    void whenMapContainsKeyElement_thenCheckByMembershipReturnsTrue() {
+        given:
         def map = [a: 'd', b: 'e', c: 'f']
 
-        assertTrue('a' in map)
+        expect:
-        assertFalse('f' in map)
+        'a' in map
+        'f' !in map
     }
 
-    @Test
+    def "whenMapContainsFalseBooleanValues_thenCheckReturnsFalse"() {
-    void whenMapContainsFalseBooleanValues_thenCheckReturnsFalse() {
+        given:
         def map = [a: true, b: false, c: null]
 
-        assertTrue(map.containsKey('b'))
+        expect:
-        assertTrue('a' in map)
+        map.containsKey('b')
-        assertFalse('b' in map)
+        'a' in map
-        assertFalse('c' in map)
+        'b' !in map // get value of key 'b' and does the assertion
+        'c' !in map
     }
 
-    @Test
+    def "givenMapOfPerson_whenUsingStreamMatching_thenShouldEvaluateMap"() {
-    void givenMapOfPerson_whenUsingStreamMatching_thenShouldEvaluateMap() {
+        expect:
-        assertTrue(personMap.keySet().stream().anyMatch {it == "Regina"})
+        personMap.keySet().stream()
-        assertFalse(personMap.keySet().stream().allMatch {it == "Albert"})
+                 .anyMatch { it == "Regina" }
-        assertFalse(personMap.values().stream().allMatch {it.age < 30})
+        !personMap.keySet().stream()
-        assertTrue(personMap.entrySet().stream().anyMatch {it.key == "Abagail" && it.value.lastname == "Ballard"})
+                  .allMatch { it == "Albert" }
+        !personMap.values().stream()
+                  .allMatch { it.age < 30 }
+        personMap.entrySet().stream()
+                 .anyMatch { it.key == "Abagail" && it.value.lastname == "Ballard" }
     }
 
-    @Test
+    def "givenMapOfPerson_whenUsingCollectionMatching_thenShouldEvaluateMap"() {
-    void givenMapOfPerson_whenUsingCollectionMatching_thenShouldEvaluateMap() {
+        expect:
-        assertTrue(personMap.keySet().any {it == "Regina"})
+        personMap.keySet().any { it == "Regina" }
-        assertFalse(personMap.keySet().every {it == "Albert"})
+        !personMap.keySet().every { it == "Albert" }
-        assertFalse(personMap.values().every {it.age < 30})
+        !personMap.values().every { it.age < 30 }
-        assertTrue(personMap.any {firstname, person -> firstname == "Abagail" && person.lastname == "Ballard"})
+        personMap.any { firstname, person -> firstname == "Abagail" && person.lastname == "Ballard" }
     }
 
-    @Test
+    def "givenMapOfPerson_whenUsingCollectionFind_thenShouldReturnElements"() {
-    void givenMapOfPerson_whenUsingCollectionFind_thenShouldReturnElements() {
+        expect:
-        assertNotNull(personMap.find {it.key == "Abagail" && it.value.lastname == "Ballard"})
+        personMap.find { it.key == "Abagail" && it.value.lastname == "Ballard" }
-        assertTrue(personMap.findAll {it.value.age > 20}.size() == 3)
+        personMap.findAll { it.value.age > 20 }.size() == 3
     }
 
-    @Test
+    def "givenMapOfPerson_whenUsingStreamFind_thenShouldReturnElements"() {
-    void givenMapOfPerson_whenUsingStreamFind_thenShouldReturnElements() {
+        expect:
-        assertTrue(
+        personMap.entrySet().stream()
-          personMap.entrySet().stream()
+                 .filter { it.key == "Abagail" && it.value.lastname == "Ballard" }
-            .filter {it.key == "Abagail" && it.value.lastname == "Ballard"}
+                 .findAny()
-            .findAny().isPresent())
+                 .isPresent()
-        assertTrue(
+
-          personMap.entrySet().stream()
+        personMap.entrySet().stream()
-            .filter {it.value.age > 20}
+                 .filter { it.value.age > 20 }
-            .findAll().size() == 3)
+                 .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
+    String firstname
-    private String lastname
+    String lastname
-    private Integer age
+    Integer age
-
-    Person(String firstname, String lastname, Integer age) {
-        this.firstname = firstname
-        this.lastname = lastname
-        this.age = age
-    }
-
-    String getFirstname() {
-        return firstname
-    }
-
-    void setFirstname(String firstname) {
-        this.firstname = firstname
-    }
-
-    String getLastname() {
-        return lastname
-    }
-
-    void setLastname(String lastname) {
-        this.lastname = lastname
-    }
-
-    Integer getAge() {
-        return age
-    }
-
-    void setAge(Integer age) {
-        this.age = age
-    }
 }

core-groovy-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 {
+    def "whenSetContainsElement_thenCheckReturnsTrue"() {
-
+        given:
-    @Test
-    void whenSetContainsElement_thenCheckReturnsTrue() {
         def set = ['a', 'b', 'c'] as Set
 
-        assertTrue(set.contains('a'))
+        expect:
-        assertTrue('a' in set)
+        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 spock.lang.Specification
-import org.junit.Test
 
-import static org.junit.Assert.*
+class IterateMapUnitTest extends Specification {
 
-class IterateMapUnitTest {
+    final Map map = [
-
+            'FF0000': 'Red',
-    @Test
+            '00FF00': 'Lime',
-    void whenUsingEach_thenMapIsIterated() {
+            '0000FF': 'Blue',
-        def map = [
+            'FFFF00': 'Yellow',
-                'FF0000' : 'Red',
+            'E6E6FA': 'Lavender',
-                '00FF00' : 'Lime',
+            'D8BFD8': 'Thistle',
-                '0000FF' : 'Blue',
+            'DDA0DD': 'Plum',
-                'FFFF00' : 'Yellow'
+    ]
-        ]
 
+    def "whenUsingEach_thenMapIsIterated"() {
+        expect:
         map.each { println "Hex Code: $it.key = Color Name: $it.value" }
     }
 
-    @Test
+    def "whenUsingEachWithEntry_thenMapIsIterated"() {
-    void whenUsingEachWithEntry_thenMapIsIterated() {
+        expect:
-        def map = [
-                'E6E6FA' : 'Lavender',
-                'D8BFD8' : 'Thistle',
-                'DDA0DD' : 'Plum',
-        ]
-
         map.each { entry -> println "Hex Code: $entry.key = Color Name: $entry.value" }
     }
 
-    @Test
+    def "whenUsingEachWithKeyAndValue_thenMapIsIterated"() {
-    void whenUsingEachWithKeyAndValue_thenMapIsIterated() {
+        expect:
-        def map = [
-                '000000' : 'Black',
-                'FFFFFF' : 'White',
-                '808080' : 'Gray'
-        ]
-
         map.each { key, val ->
             println "Hex Code: $key = Color Name $val"
         }
     }
 
-    @Test
+    def "whenUsingEachWithIndexAndEntry_thenMapIsIterated"() {
-    void whenUsingEachWithIndexAndEntry_thenMapIsIterated() {
+        expect:
-        def map = [
-                '800080' : 'Purple',
-                '4B0082' : 'Indigo',
-                '6A5ACD' : 'Slate Blue'
-        ]
-
         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
+    def "whenUsingEachWithIndexAndKeyAndValue_thenMapIsIterated"() {
-    void whenUsingEachWithIndexAndKeyAndValue_thenMapIsIterated() {
+        expect:
-        def map = [
-                'FFA07A' : 'Light Salmon',
-                'FF7F50' : 'Coral',
-                'FF6347' : 'Tomato',
-                'FF4500' : 'Orange Red'
-        ]
-
         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
+    def "whenUsingForLoop_thenMapIsIterated"() {
-    void whenUsingForLoop_thenMapIsIterated() {
+        expect:
-        def map = [
-                '2E8B57' : 'Seagreen',
-                '228B22' : 'Forest Green',
-                '008000' : 'Green'
-        ]
-
         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 spock.lang.Specification
-import org.junit.Test
 
-class ListUnitTest {
+class ListUnitTest extends Specification {
-
-    @Test
-    void testCreateList() {
 
+    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
+    def "testCreateEmptyList"() {
-    void testCreateEmptyList() {
+        when:
-
         def emptyList = []
-        assertTrue(emptyList.size() == 0)
+
+        then:
+        emptyList.isEmpty()
     }
 
-    @Test
+    def "testCompareTwoLists"() {
-    void testCompareTwoLists() {
+        when:
-
         def list1 = [5, 6.0, 'p']
         def list2 = [5, 6.0, 'p']
-        assertTrue(list1 == list2)
+
+        then:
+        list1 == list2
     }
 
-    @Test
+    def "testGetItemsFromList"() {
-    void testGetItemsFromList(){
+        when:
-
         def list = ["Hello", "World"]
 
-        assertTrue(list.get(1) == "World")
+        then:
-        assertTrue(list[1] == "World")
+        list.get(1) == "World"
-        assertTrue(list[-1] == "World")
+        list[1] == "World"
-        assertTrue(list.getAt(1) == "World")
+        list[-1] == "World"
-        assertTrue(list.getAt(-2) == "Hello")
+        list.getAt(1) == "World"
+        list.getAt(-2) == "Hello"
     }
 
-    @Test
+    def "testAddItemsToList"() {
-    void testAddItemsToList() {
+        given:
+        def list1 = []
+        def list2 = []
+        def list3 = [1, 2]
 
-        def list = []
+        when:
+        list1 << 1 // [1]
+        list1.add("Apple") // [1, "Apple"]
 
-        list << 1
+        list2[2] = "Box"   // [null, "Box"]
-        list.add("Apple")
+        list2[4] = true    // [null, "Box", null, true]
-        assertTrue(list == [1, "Apple"])
 
-        list[2] = "Box"
+        list1.add(1, 6.0) // [1, 6.0, "Apple"] 
-        list[4] = true
+        list1 += list3                    // [1, 6.0, "Apple", 1, 2]
-        assertTrue(list == [1, "Apple", "Box", null, true])
+        list1 += 12                       // [1, 6.0, "Apple", 1, 2, 12]
 
-        list.add(1, 6.0)
+        then:
-        assertTrue(list == [1, 6.0, "Apple", "Box", null, true])
+        list1 == [1, 6.0, "Apple", 1, 2, 12]
-
+        list2 == [null, null, "Box", null, true]
-        def list2 = [1, 2]
-        list += list2
-        list += 12
-        assertTrue(list == [1, 6.0, "Apple", "Box", null, true, 1, 2, 12])
     }
 
-    @Test
+    def "testUpdateItemsInList"() {
-    void testUpdateItemsInList() {
+        given:
+        def list = [1, "Apple", 80, "App"]
 
-        def list =[1, "Apple", 80, "App"]
+        when:
         list[1] = "Box"
-        list.set(2,90)
+        list.set(2, 90)
-        assertTrue(list == [1, "Box", 90, "App"])
+
+        then:
+        list == [1, "Box", 90, "App"]
     }
 
-    @Test
+    def "testRemoveItemsFromList"() {
-    void testRemoveItemsFromList(){
+        given:
-
         def list = [1, 2, 3, 4, 5, 5, 6, 6, 7]
 
-        list.remove(3)
+        when:
-        assertTrue(list == [1, 2, 3, 5, 5, 6, 6, 7])
+        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)
+        then:
-        assertTrue(list == [1, 2, 3, 5, 6, 6, 7])
+        list == [1, 2, 3, 5, 7]
-
-        assertTrue(list - 6 == [1, 2, 3, 5, 7])
     }
 
-    @Test
+    def "testIteratingOnAList"() {
-    void 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
+    def "testCollectingToAnotherList"() {
-    void 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
+    def "testJoinItemsInAList"() {
-    void testJoinItemsInAList(){
+        expect:
-        assertTrue(["One", "Two", "Three"].join(",") == "One,Two,Three")
+        ["One", "Two", "Three"].join(",") == "One,Two,Three"
     }
 
-    @Test
+    def "testFilteringOnLists"() {
-    void 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})
+        expect:
-
+        filterList.find { it > 3 } == 4
-        assertTrue(conditionList.any{ it%2 == 0})
+        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
+    def "testGetUniqueItemsInAList"() {
-    void testGetUniqueItemsInAList(){
+        given:
-        assertTrue([1, 3, 3, 4].toUnique() == [1, 3, 4])
-
         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
+    def "testSorting"() {
-    void testSorting(){
+        given:
-
+        Comparator naturalOrder = { a, b -> a == b ? 0 : a < b ? -1 : 1 }
-        assertTrue([1, 2, 1, 0].sort() == [0, 1, 1, 2])
-        Comparator mc = {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 spock.lang.Specification
-import org.junit.Test
 
-class MapTest{
+class MapTest extends Specification {
-
-    @Test
-    void createMap() {
 
+    def "createMap"() {
+        when:
         def emptyMap = [:]
-        assertNotNull(emptyMap)
+        def map = [name: "Jerry", age: 42, city: "New York"]
 
-        assertTrue(emptyMap instanceof java.util.LinkedHashMap)
+        then:
-
+        emptyMap != null
-        def map = [name:"Jerry", age: 42, city: "New York"]
+        emptyMap instanceof java.util.LinkedHashMap
-        assertTrue(map.size() == 3)
+        map.size() == 3
     }
 
-    @Test
+    def "addItemsToMap"() {
-    void addItemsToMap() {
+        given:
-
+        def map = [name: "Jerry"]
-        def map = [name:"Jerry"]
-
-        map["age"] = 42
-
-        map.city = "New York"
-
         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"])
+        appendToMap.plus([1: 20])
-        assertTrue(hobbyMap.hobby == "Singing")
+        appendToMap << [2: 30]
-        assertTrue(hobbyMap[hobbyLiteral] == "Singing")
-        
-        map.plus([1:20]) // returns new map
 
-        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
+    def "getItemsFromMap"() {
-    void getItemsFromMap() {
+        when:
-
+        def map = [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
-
-        assertTrue(map["name"] == "Jerry")
-
-        assertTrue(map.name == "Jerry")
-
         def propertyAge = "age"
-        assertTrue(map[propertyAge] == 42)
+
+        then:
+        map["name"] == "Jerry"
+        map.name == "Jerry"
+        map[propertyAge] == 42
+        map."$propertyAge" == 42
     }
 
-    @Test
+    def "removeItemsFromMap"() {
-    void 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]);
+        then:
-        assertTrue(minusMap == [1:20, a:30, ba:67, 6:39, 7:49])
+        minusMap == [1: 20, a: 30, ba: 67, 6: 39, 7: 49]
-
+        removeAllKeysOfTypeString == [1: 20, 6: 39, 7: 49]
-        minusMap.removeAll{it -> it.key instanceof String}
+        retainAllEntriesWhereValueIsEven == [1: 20, a: 30]
-        assertTrue( minusMap == [ 1:20, 6:39, 7:49])
-
-        minusMap.retainAll{it -> it.value %2 == 0}
-        assertTrue( minusMap == [1:20])
     }
 
-    @Test
+    def "iteratingOnMaps"() {
-    void iteratingOnMaps(){
+        when:
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
+        def map = [name: "Jerry", age: 42, city: "New York", hobby: "Singing"]
 
-        map.each{ entry -> println "$entry.key: $entry.value" }
+        then:
-
+        map.each { entry -> println "$entry.key: $entry.value" }
-        map.eachWithIndex{ entry, i -> println "$i $entry.key: $entry.value" }
+        map.eachWithIndex { entry, i -> println "$i $entry.key: $entry.value" }
-
+        map.eachWithIndex { key, value, i -> println "$i $key: $value" }
-        map.eachWithIndex{ key, value, i -> println "$i $key: $value" }
     }
 
-    @Test
+    def "filteringAndSearchingMaps"() {
-    void filteringAndSearchingMaps(){
+        given:
-        def map = [name:"Jerry", age: 42, city: "New York", hobby:"Singing"]
+        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
+    def "collect"() {
-    void collect(){
+        given:
-
+        def map = [
-        def map = [1: [name:"Jerry", age: 42, city: "New York"],
+                1: [name: "Jerry", age: 42, city: "New York"],
-            2: [name:"Long", age: 25, city: "New York"],
+                2: [name: "Long", age: 25, city: "New York"],
-            3: [name:"Dustin", age: 29, city: "New York"],
+                3: [name: "Dustin", age: 29, city: "New York"],
-            4: [name:"Dustin", age: 34, 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"])
 
+        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
+    def "group"() {
-    void group(){
+        given:
-        def map = [1:20, 2: 40, 3: 11, 4: 93]
+        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]])
 
+        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
+    def "sorting"() {
-    void sorting(){
+        given:
-        def map = [ab:20, a: 40, cb: 11, ba: 93]
+        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>
+            <id>maven_central</id>
-            <url>https://jcenter.bintray.com</url>
+            <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 spock.lang.Specification
-import org.junit.Test
 
-class RemovePrefixTest {
+class RemovePrefixTest extends Specification {
 
-
+    def "whenCasePrefixIsRemoved_thenReturnTrue"() {
-    @Test
+        given:
-    public void whenCasePrefixIsRemoved_thenReturnTrue() {
         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
+    def "whenPrefixIsRemoved_thenReturnTrue"() {
-    public void 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
+    def "whenPrefixIsRemovedUsingRegex_thenReturnTrue"() {
-    public void 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 
+    def "whenPrefixIsRemovedUsingReplaceFirst_thenReturnTrue"() {
-    public void whenPrefixIsRemovedUsingReplaceFirst_thenReturnTrue() {
+        given:
-        def regex = ~"^groovy" 
+        def regex = ~"^groovy"
-        String trimPrefix = "groovyTutorials at Baeldung's groovy page" 
+        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
+    def "whenPrefixIsRemovedUsingReplaceAll_thenReturnTrue"() {
-    public void 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>
+            <id>maven_central</id>
-            <url>https://jcenter.bintray.com</url>
+            <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)
+        return new File(filePath).readLines()
-        def lines = file.readLines()
-        return lines
     }
 
     /**
@@ -37,9 +36,7 @@ class ReadFile {
      * @return
      */
     String readFileString(String filePath) {
-        File file = new File(filePath)
+        return new File(filePath).text
-        String fileContent = file.text
-        return fileContent
     }
 
     /**
@@ -48,9 +45,7 @@ class ReadFile {
      * @return
      */
     String readFileStringWithCharset(String filePath) {
-        File file = new File(filePath)
+        return new File(filePath).getText("UTF-8")
-        String utf8Content = file.getText("UTF-8")
-        return utf8Content
     }
 
     /**
@@ -59,49 +54,44 @@ class ReadFile {
      * @return
      */
     byte[] readBinaryFile(String filePath) {
-        File file = new File(filePath)
+        return new File(filePath).bytes
-        byte[] binaryContent = file.bytes
-        return binaryContent
     }
-    
+
     /**
      * 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
+        // collect api
-        def list = new File("src/main/resources/fileContent.txt").collect {it}
+        def list = new File("src/main/resources/fileContent.txt").collect { it }
-                
+
-        //as operator
+        // as operator
         def array = new File("src/main/resources/fileContent.txt") as String[]
-              
+
-        //eachline  
+        // eachline  
-        new File("src/main/resources/fileContent.txt").eachLine { line ->
+        new File("src/main/resources/fileContent.txt").eachLine { println it }
-            println line
+
-        }
-        
         //newInputStream with eachLine
-        def is = new File("src/main/resources/fileContent.txt").newInputStream()
+
-        is.eachLine {
+        // try-with-resources automatically closes BufferedInputStream resource
-            println it
+        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]
+        return [first, ' ', last]
-          .inject(new StringBuffer('My name is '), { initial, name -> initial.append(name); return initial }).toString()
+                .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
-            noOfLines instanceof Integer
+        noOfLines instanceof Integer
-            assert noOfLines, 3
+        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""")
-    
     }
 
-    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
+        lines
-            encodedContent instanceof String
+        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
+        fileContent
-            binaryContent instanceof byte[]
+        fileContent instanceof String
-            binaryContent.length == 329
+        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 '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 (?, ?)',
-            sql.execute("INSERT INTO PROJECT_6 (NAME, URL) VALUES (:name, :url)", [name: 'REST with Spring', url: 'github.com/eugenp/REST-With-Spring'])
+                        '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
-            account instanceof Account
+        account instanceof Account
-            account.id == '1234'
+        account.id == '1234'
-            account.value == 15.6
+        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
-            jsonPretty == '{\n    "value": 15.6,\n    "createdAt": "01/01/2018",\n    "id": "123456"\n}'
+        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 {
+class ConcatenateTest extends Specification {
-    
+
-    void testSimpleConcat() {
+    final Concatenate NAME = new Concatenate(first: 'Joe', last: 'Smith')
-        def name = new Concatenate()
+    final String EXPECTED = "My name is Joe Smith";
-        name.first = 'Joe';
+
-        name.last = 'Smith';
+    def "SimpleConcat"() {
-        def expected = 'My name is Joe Smith'
+        expect:
-        assertToString(name.doSimpleConcat(), expected)
+        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)
     }
 
-    void testConcatUsingLeftShiftOperator() {
+    def "ConcatUsingGString"() {
-        def name = new Concatenate()
+        expect:
-        name.first = "Joe";
+        NAME.doConcatUsingGString() == EXPECTED
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingLeftShiftOperator(), expected)
     }
 
-    void testConcatUsingArrayJoinMethod() {
+    def "ConcatUsingGStringClosures"() {
-        def name = new Concatenate()
+        expect:
-        name.first = "Joe";
+        NAME.doConcatUsingGStringClosures() == EXPECTED
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingArrayJoinMethod(), expected)
     }
 
-    void testConcatUsingArrayInjectMethod() {
+    def "ConcatUsingStringConcatMethod"() {
-        def name = new Concatenate()
+        expect:
-        name.first = "Joe";
+        NAME.doConcatUsingStringConcatMethod() == EXPECTED
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingArrayInjectMethod(), expected)
     }
 
-    void testConcatUsingStringBuilder() {
+    def "ConcatUsingLeftShiftOperator"() {
-        def name = new Concatenate()
+        expect:
-        name.first = "Joe";
+        NAME.doConcatUsingLeftShiftOperator() == EXPECTED
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingStringBuilder(), expected)
     }
 
-    void testConcatUsingStringBuffer() {
+    def "ConcatUsingArrayJoinMethod"() {
-        def name = new Concatenate()
+        expect:
-        name.first = "Joe";
+        NAME.doConcatUsingArrayJoinMethod() == EXPECTED
-        name.last = "Smith";
-        def expected = "My name is Joe Smith"
-        assertToString(name.doConcatUsingStringBuffer(), expected)
     }
 
-    void testConcatMultilineUsingStringConcatMethod() {
+    def "ConcatUsingArrayInjectMethod"() {
-        def name = new Concatenate()
+        expect:
-        name.first = '''Joe
+        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''';
+                         Junior'''
-        assertToString(name.doConcatUsingStringConcatMethod(), expected)
+        NAME.doConcatUsingStringConcatMethod() == expected
     }
 
-    void testGStringvsClosure(){
+    def "GStringvsClosure"() {
-        def first = "Joe";
+        given:
-        def last = "Smith";
+        def eagerGString = "My name is $NAME.first $NAME.last"
-        def eagerGString = "My name is $first $last"
+        def lazyGString = "My name is ${-> NAME.first} ${-> NAME.last}"
-        def lazyGString = "My name is ${-> first} ${-> last}"
 
-        assert eagerGString == "My name is Joe Smith"
+        expect:
-        assert lazyGString == "My name is Joe Smith"
+        eagerGString == "My name is Joe Smith"
-        first = "David";
+        lazyGString == "My name is Joe Smith"
-        assert eagerGString == "My name is Joe Smith"
+    }
-        assert lazyGString == "My name is David 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
+class ConvertStringToInt extends Specification {
-import static org.junit.Assert.assertNull
 
-class ConvertStringToInt {
+    final String STRING_NUM = "123"
+    final int EXPECTED_INT = 123
 
-    @Test
+    def "givenString_whenUsingAsInteger_thenConvertToInteger"() {
-    void givenString_whenUsingAsInteger_thenConvertToInteger() {
+        given:
-        def stringNum = "123"
         def invalidString = "123a"
-        Integer expectedInteger = 123
+        Integer integerNum = STRING_NUM as Integer
-        Integer integerNum = stringNum as Integer
+
+        when:
         def intNum = invalidString?.isInteger() ? invalidString as Integer : null
 
-        assertNull(null, intNum)
+        then:
-        assertEquals(integerNum, expectedInteger)
+        intNum == null
+        integerNum == EXPECTED_INT
     }
 
-    @Test
+    def "givenString_whenUsingAsInt_thenConvertToInt"() {
-    void givenString_whenUsingAsInt_thenConvertToInt() {
+        given:
-        def stringNum = "123"
+        int intNum = STRING_NUM as int
-        int expectedInt = 123
-        int intNum = stringNum as int
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
+    def "givenString_whenUsingToInteger_thenConvertToInteger"() {
-    void givenString_whenUsingToInteger_thenConvertToInteger() {
+        given:
-        def stringNum = "123"
+        int intNum = STRING_NUM.toInteger()
-        int expectedInt = 123
-        int intNum = stringNum.toInteger()
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
+    def "givenString_whenUsingParseInt_thenConvertToInteger"() {
-    void givenString_whenUsingParseInt_thenConvertToInteger() {
+        given:
-        def stringNum = "123"
+        int intNum = Integer.parseInt(STRING_NUM)
-        int expectedInt = 123
-        int intNum = Integer.parseInt(stringNum)
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
+    def "givenString_whenUsingValueOf_thenConvertToInteger"() {
-    void givenString_whenUsingValueOf_thenConvertToInteger() {
+        given:
-        def stringNum = "123"
+        int intNum = Integer.valueOf(STRING_NUM)
-        int expectedInt = 123
-        int intNum = Integer.valueOf(stringNum)
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
+    def "givenString_whenUsingIntValue_thenConvertToInteger"() {
-    void givenString_whenUsingIntValue_thenConvertToInteger() {
+        given:
-        def stringNum = "123"
+        int intNum = Integer.valueOf(STRING_NUM).intValue()
-        int expectedInt = 123
-        int intNum = new Integer(stringNum).intValue()
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
+    def "givenString_whenUsingNewInteger_thenConvertToInteger"() {
-    void givenString_whenUsingNewInteger_thenConvertToInteger() {
+        given:
-        def stringNum = "123"
+        Integer intNum = Integer.valueOf(STRING_NUM)
-        int expectedInt = 123
-        int intNum = new Integer(stringNum)
 
-        assertEquals(intNum, expectedInt)
+        expect:
+        intNum == EXPECTED_INT
     }
 
-    @Test
+    def "givenString_whenUsingDecimalFormat_thenConvertToInteger"() {
-    void givenString_whenUsingDecimalFormat_thenConvertToInteger() {
+        given:
-        def stringNum = "123"
-        int expectedInt = 123
         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)
+    def "givenInvalidString_whenUsingAs_thenThrowNumberFormatException"() {
-    void givenInvalidString_whenUsingAs_thenThrowNumberFormatException() {
+        given:
         def invalidString = "123a"
+
+        when:
         invalidString as Integer
+
+        then:
+        thrown(NumberFormatException)
     }
 
-    @Test(expected = NullPointerException.class)
+    def "givenNullString_whenUsingToInteger_thenThrowNullPointerException"() {
-    void givenNullString_whenUsingToInteger_thenThrowNullPointerException() {
+        given:
         def invalidString = null
+
+        when:
         invalidString.toInteger()
+
+        then:
+        thrown(NullPointerException)
     }
 
-    @Test
+    def "givenString_whenUsingIsInteger_thenCheckIfCorrectValue"() {
-    void 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)
+        then:
-        assertEquals(123, correctNum)
+        !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 spock.lang.Specification
-import org.junit.Test
 
-class CharacterInGroovy {
+class CharacterInGroovy extends Specification {
 
-    @Test
+    def 'character'() {
-    void 'character'() {
+        given:
         char a = 'A' as char
         char b = 'B' as char
         char c = (char) 'C'
 
-        Assert.assertTrue(a instanceof Character)
+        expect:
-        Assert.assertTrue(b instanceof Character)
+        a instanceof Character
-        Assert.assertTrue(c 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 spock.lang.Specification
-import org.junit.Test
 
-class DoubleQuotedString {
+class DoubleQuotedString extends Specification {
 
-    @Test
+    def 'escape double quoted string'() {
-    void 'escape double quoted string'() {
+        given:
         def example = "Hello \"world\"!"
 
-        println(example)
+        expect:
+        example == 'Hello "world"!'
     }
 
-    @Test
+    def 'String ang GString'() {
-    void 'String ang GString'() {
+        given:
         def string = "example"
         def stringWithExpression = "example${2}"
 
-        Assert.assertTrue(string instanceof String)
+        expect:
-        Assert.assertTrue(stringWithExpression instanceof GString)
+        string instanceof String
-        Assert.assertTrue(stringWithExpression.toString() instanceof String)
+        stringWithExpression instanceof GString
+        stringWithExpression.toString() instanceof String
     }
 
-    @Test
+    def 'placeholder with variable'() {
-    void 'placeholder with variable'() {
+        given:
         def name = "John"
+
+        when:
         def helloName = "Hello $name!".toString()
 
-        Assert.assertEquals("Hello John!", helloName)
+        then:
+        helloName == "Hello John!"
     }
 
-    @Test
+    def 'placeholder with expression'() {
-    void 'placeholder with expression'() {
+        given:
         def result = "result is ${2 * 2}".toString()
 
-        Assert.assertEquals("result is 4", result)
+        expect:
+        result == "result is 4"
     }
 
-    @Test
+    def 'placeholder with dotted access'() {
-    void '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
+    def 'placeholder with method call'() {
-    void '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
+    def 'GString and String hashcode'() {
-    void '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 spock.lang.Specification
-import org.junit.Test
 
-class SingleQuotedString {
+class SingleQuotedString extends Specification {
 
-    @Test
+    def 'single quoted string'() {
-    void 'single quoted string'() {
+        given:
-        def example = 'Hello world'
+        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 spock.lang.Specification
-import org.junit.Test
 
-class Strings {
+class Strings extends Specification {
 
-    @Test
+    def 'string interpolation '() {
-    void 'string interpolation '() {
+        given:
         def name = "Kacper"
 
+        when:
         def result = "Hello ${name}!"
 
-        Assert.assertEquals("Hello Kacper!", result.toString())
+        then:
+        result.toString() == "Hello Kacper!"
     }
 
-    @Test
+    def 'string concatenation'() {
-    void '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
-            msg instanceof String
+        msg instanceof String
-            assert msg == "Hello!"
+        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
-            displayMsg instanceof String
+        displayMsg instanceof String
-            assert displayMsg == "Hello, Bob!"
+        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
-            greetMsg instanceof String
+        greetMsg instanceof String
-            assert greetMsg == "Hello, from a private method!"
+        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
+        employee.greetingMessage()
-            try {
+
-                employee.greetingMessage()
-            }catch(Exception e) {
-                exception = e
-            }
-            
         then:
-            exception
+        thrown(MissingMethodException)
-            exception instanceof groovy.lang.MissingMethodException
+        specificationContext.thrownException.message ==
-            assert exception.message == "No signature of method: com.baeldung.traits.Employee.greetingMessage()"+
+                "No signature of method: com.baeldung.traits.Employee.greetingMessage() is applicable for argument types: () values: []"
-            " 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
-            emp instanceof Employee
+        emp instanceof Employee
-            assert emp.is(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
-            lastNameMsg instanceof String
+        lastNameMsg instanceof String
-            assert lastNameMsg == "Hello, Marley!"
+        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
-            employee instanceof Employee
+        employee instanceof Employee
-            assert employee.email == "a@e.com"
+        employee.email == "a@e.com"
-            assert employee.address == "baeldung.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
-            speakMsg instanceof String
+        speakMsg instanceof String
-            assert speakMsg == "Speaking!!"
+        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()
+        def walkSpeakMsg = dog.speakAndWalk()
-            println walkSpeakMsg
+        println walkSpeakMsg
+
         then:
-            walkSpeakMsg
+        walkSpeakMsg
-            walkSpeakMsg instanceof String
+        walkSpeakMsg instanceof String
-            assert walkSpeakMsg == "Walk and speak!!"
+        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 dogInstance = new Dog() as AnimalTrait
-            def basicBehaviorMsg = dogInstance.basicBehavior()
+        def basicBehaviorMsg = dogInstance.basicBehavior()
+
         then:
-            basicBehaviorMsg
+        basicBehaviorMsg
-            basicBehaviorMsg instanceof String
+        basicBehaviorMsg instanceof String
-            assert basicBehaviorMsg == "Animalistic!!"
+        basicBehaviorMsg == "Animalistic!!"
     }
-}
+}

core-groovy-modules/pom.xml

@@ -21,12 +21,12 @@
     </modules>
 
     <properties>
-        <groovy.version>2.5.7</groovy.version>
+        <groovy.version>3.0.15</groovy.version>
-        <groovy-all.version>2.5.6</groovy-all.version>
+        <groovy-all.version>3.0.15</groovy-all.version>
-        <groovy-sql.version>2.5.6</groovy-sql.version>
+        <groovy-sql.version>3.0.15</groovy-sql.version>
-        <hsqldb.version>2.4.0</hsqldb.version>
+        <hsqldb.version>2.7.1</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>
+        <gmavenplus-plugin.version>2.1.0</gmavenplus-plugin.version>
     </properties>
 
-</project>
+</project>

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

@@ -6,3 +6,4 @@
 - [New Features in Java 17](https://www.baeldung.com/java-17-new-features)
 - [Random Number Generators in Java 17](https://www.baeldung.com/java-17-random-number-generators)
 - [Sealed Classes and Interfaces in Java](https://www.baeldung.com/java-sealed-classes-interfaces)
+- [Migrate From Java 8 to Java 17](https://www.baeldung.com/java-migrate-8-to-17)