diff --git a/core-java/src/main/java/com/baeldung/java/networking/udp/EchoClient.java b/core-java/src/main/java/com/baeldung/java/networking/udp/EchoClient.java
index 1fb9af3a9d..916442533b 100644
--- a/core-java/src/main/java/com/baeldung/java/networking/udp/EchoClient.java
+++ b/core-java/src/main/java/com/baeldung/java/networking/udp/EchoClient.java
@@ -24,7 +24,7 @@ public class EchoClient {
     public String sendEcho(String msg) {
         DatagramPacket packet = null;
         try {
-            buf=msg.getBytes();
+            buf = msg.getBytes();
             packet = new DatagramPacket(buf, buf.length, address, 4445);
             socket.send(packet);
             packet = new DatagramPacket(buf, buf.length);
diff --git a/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeUnitTest.java b/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeUnitTest.java
index 906d641632..57e1f33280 100644
--- a/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/datetime/UseLocalDateTimeUnitTest.java
@@ -8,12 +8,12 @@ import org.junit.Assert;
 import org.junit.Test;
 
 public class UseLocalDateTimeUnitTest {
-    
+
     UseLocalDateTime useLocalDateTime = new UseLocalDateTime();
-    
+
     @Test
-    public void givenString_whenUsingParse_thenLocalDateTime(){
-        Assert.assertEquals(LocalDate.of(2016, Month.MAY, 10),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalDate());
-        Assert.assertEquals(LocalTime.of(6,30),useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalTime());
+    public void givenString_whenUsingParse_thenLocalDateTime() {
+        Assert.assertEquals(LocalDate.of(2016, Month.MAY, 10), useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalDate());
+        Assert.assertEquals(LocalTime.of(6, 30), useLocalDateTime.getLocalDateTimeUsingParseMethod("2016-05-10T06:30").toLocalTime());
     }
 }
diff --git a/core-java/src/test/java/com/baeldung/datetime/UseLocalDateUnitTest.java b/core-java/src/test/java/com/baeldung/datetime/UseLocalDateUnitTest.java
index dcfca792af..8f1997e9e8 100644
--- a/core-java/src/test/java/com/baeldung/datetime/UseLocalDateUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/datetime/UseLocalDateUnitTest.java
@@ -8,47 +8,47 @@ import org.junit.Assert;
 import org.junit.Test;
 
 public class UseLocalDateUnitTest {
-    
+
     UseLocalDate useLocalDate = new UseLocalDate();
-    
+
     @Test
-    public void givenValues_whenUsingFactoryOf_thenLocalDate(){
-        Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingFactoryOfMethod(2016,5,10).toString());
+    public void givenValues_whenUsingFactoryOf_thenLocalDate() {
+        Assert.assertEquals("2016-05-10", useLocalDate.getLocalDateUsingFactoryOfMethod(2016, 5, 10).toString());
     }
-    
+
     @Test
-    public void givenString_whenUsingParse_thenLocalDate(){
-        Assert.assertEquals("2016-05-10",useLocalDate.getLocalDateUsingParseMethod("2016-05-10").toString());
+    public void givenString_whenUsingParse_thenLocalDate() {
+        Assert.assertEquals("2016-05-10", useLocalDate.getLocalDateUsingParseMethod("2016-05-10").toString());
     }
-    
+
     @Test
-    public void whenUsingClock_thenLocalDate(){
-        Assert.assertEquals(LocalDate.now(),useLocalDate.getLocalDateFromClock());
+    public void whenUsingClock_thenLocalDate() {
+        Assert.assertEquals(LocalDate.now(), useLocalDate.getLocalDateFromClock());
     }
-    
+
     @Test
-    public void givenDate_whenUsingPlus_thenNextDay(){
-        Assert.assertEquals(LocalDate.now().plusDays(1),useLocalDate.getNextDay(LocalDate.now()));
+    public void givenDate_whenUsingPlus_thenNextDay() {
+        Assert.assertEquals(LocalDate.now().plusDays(1), useLocalDate.getNextDay(LocalDate.now()));
     }
-    
+
     @Test
-    public void givenDate_whenUsingMinus_thenPreviousDay(){
-        Assert.assertEquals(LocalDate.now().minusDays(1),useLocalDate.getPreviousDay(LocalDate.now()));
+    public void givenDate_whenUsingMinus_thenPreviousDay() {
+        Assert.assertEquals(LocalDate.now().minusDays(1), useLocalDate.getPreviousDay(LocalDate.now()));
     }
-    
+
     @Test
-    public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek(){
-        Assert.assertEquals(DayOfWeek.SUNDAY,useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22")));
+    public void givenToday_whenUsingGetDayOfWeek_thenDayOfWeek() {
+        Assert.assertEquals(DayOfWeek.SUNDAY, useLocalDate.getDayOfWeek(LocalDate.parse("2016-05-22")));
     }
-    
+
     @Test
-    public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth(){
-        Assert.assertEquals(1,useLocalDate.getFirstDayOfMonth().getDayOfMonth());
+    public void givenToday_whenUsingWithTemporalAdjuster_thenFirstDayOfMonth() {
+        Assert.assertEquals(1, useLocalDate.getFirstDayOfMonth().getDayOfMonth());
     }
-    
+
     @Test
-    public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight(){
-        Assert.assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"),useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
+    public void givenLocalDate_whenUsingAtStartOfDay_thenReturnMidnight() {
+        Assert.assertEquals(LocalDateTime.parse("2016-05-22T00:00:00"), useLocalDate.getStartOfDay(LocalDate.parse("2016-05-22")));
     }
 
 }
diff --git a/core-java/src/test/java/com/baeldung/datetime/UseLocalTimeUnitTest.java b/core-java/src/test/java/com/baeldung/datetime/UseLocalTimeUnitTest.java
index 520b79d4bf..996e200ae9 100644
--- a/core-java/src/test/java/com/baeldung/datetime/UseLocalTimeUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/datetime/UseLocalTimeUnitTest.java
@@ -6,31 +6,31 @@ import org.junit.Assert;
 import org.junit.Test;
 
 public class UseLocalTimeUnitTest {
-    
+
     UseLocalTime useLocalTime = new UseLocalTime();
-    
+
     @Test
-    public void givenValues_whenUsingFactoryOf_thenLocalTime(){
-        Assert.assertEquals("07:07:07",useLocalTime.getLocalTimeUsingFactoryOfMethod(7,7,7).toString());
+    public void givenValues_whenUsingFactoryOf_thenLocalTime() {
+        Assert.assertEquals("07:07:07", useLocalTime.getLocalTimeUsingFactoryOfMethod(7, 7, 7).toString());
     }
-    
+
     @Test
-    public void givenString_whenUsingParse_thenLocalTime(){
-        Assert.assertEquals("06:30",useLocalTime.getLocalTimeUsingParseMethod("06:30").toString());
+    public void givenString_whenUsingParse_thenLocalTime() {
+        Assert.assertEquals("06:30", useLocalTime.getLocalTimeUsingParseMethod("06:30").toString());
     }
-    
+
     @Test
-    public void givenTime_whenAddHour_thenLocalTime(){
-        Assert.assertEquals("07:30",useLocalTime.addAnHour(LocalTime.of(6,30)).toString());
+    public void givenTime_whenAddHour_thenLocalTime() {
+        Assert.assertEquals("07:30", useLocalTime.addAnHour(LocalTime.of(6, 30)).toString());
     }
-    
+
     @Test
-    public void getHourFromLocalTime(){
-        Assert.assertEquals(1, useLocalTime.getHourFromLocalTime(LocalTime.of(1,1)));
+    public void getHourFromLocalTime() {
+        Assert.assertEquals(1, useLocalTime.getHourFromLocalTime(LocalTime.of(1, 1)));
     }
-    
+
     @Test
-    public void getLocalTimeWithMinuteSetToValue(){
-        Assert.assertEquals(LocalTime.of(10, 20), useLocalTime.getLocalTimeWithMinuteSetToValue(LocalTime.of(10,10), 20));
+    public void getLocalTimeWithMinuteSetToValue() {
+        Assert.assertEquals(LocalTime.of(10, 20), useLocalTime.getLocalTimeWithMinuteSetToValue(LocalTime.of(10, 10), 20));
     }
 }
diff --git a/core-java/src/test/java/com/baeldung/datetime/UsePeriodUnitTest.java b/core-java/src/test/java/com/baeldung/datetime/UsePeriodUnitTest.java
index a060d974ed..7c030c328a 100644
--- a/core-java/src/test/java/com/baeldung/datetime/UsePeriodUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/datetime/UsePeriodUnitTest.java
@@ -7,20 +7,20 @@ import org.junit.Assert;
 import org.junit.Test;
 
 public class UsePeriodUnitTest {
-    UsePeriod usingPeriod=new UsePeriod();
-    
+    UsePeriod usingPeriod = new UsePeriod();
+
     @Test
-    public void givenPeriodAndLocalDate_thenCalculateModifiedDate(){
+    public void givenPeriodAndLocalDate_thenCalculateModifiedDate() {
         Period period = Period.ofDays(1);
         LocalDate localDate = LocalDate.parse("2007-05-10");
-        Assert.assertEquals(localDate.plusDays(1),usingPeriod.modifyDates(localDate, period));
+        Assert.assertEquals(localDate.plusDays(1), usingPeriod.modifyDates(localDate, period));
     }
-    
+
     @Test
-    public void givenDates_thenGetPeriod(){
+    public void givenDates_thenGetPeriod() {
         LocalDate localDate1 = LocalDate.parse("2007-05-10");
         LocalDate localDate2 = LocalDate.parse("2007-05-15");
-        
+
         Assert.assertEquals(Period.ofDays(5), usingPeriod.getDifferenceBetweenDates(localDate1, localDate2));
     }
 }
diff --git a/core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeUnitTest.java b/core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeUnitTest.java
index d5652430fe..5fb079b94c 100644
--- a/core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/datetime/UseZonedDateTimeUnitTest.java
@@ -8,13 +8,13 @@ import org.junit.Assert;
 import org.junit.Test;
 
 public class UseZonedDateTimeUnitTest {
-    
-    UseZonedDateTime zonedDateTime=new UseZonedDateTime();
-    
+
+    UseZonedDateTime zonedDateTime = new UseZonedDateTime();
+
     @Test
-    public void givenZoneId_thenZonedDateTime(){
-        ZoneId zoneId=ZoneId.of("Europe/Paris");
-        ZonedDateTime zonedDatetime=zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
-        Assert.assertEquals(zoneId,ZoneId.from(zonedDatetime));
+    public void givenZoneId_thenZonedDateTime() {
+        ZoneId zoneId = ZoneId.of("Europe/Paris");
+        ZonedDateTime zonedDatetime = zonedDateTime.getZonedDateTime(LocalDateTime.parse("2016-05-20T06:30"), zoneId);
+        Assert.assertEquals(zoneId, ZoneId.from(zonedDatetime));
     }
 }
diff --git a/core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoderUnitTest.java b/core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoderUnitTest.java
index 0e3ec29dfd..c944dfa6fe 100644
--- a/core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoderUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/encoderdecoder/EncoderDecoderUnitTest.java
@@ -32,7 +32,6 @@ public class EncoderDecoderUnitTest {
         return encoded;
     }
 
-
     private String decode(String value) {
         String decoded = null;
         try {
@@ -59,9 +58,7 @@ public class EncoderDecoderUnitTest {
         requestParams.put("key2", "value@!$2");
         requestParams.put("key3", "value%3");
 
-        String encodedURL = requestParams.keySet().stream()
-          .map(key -> key + "=" + encodeValue(requestParams.get(key)))
-          .collect(joining("&", "http://www.baeldung.com?", ""));
+        String encodedURL = requestParams.keySet().stream().map(key -> key + "=" + encodeValue(requestParams.get(key))).collect(joining("&", "http://www.baeldung.com?", ""));
 
         Assert.assertThat(testUrl, CoreMatchers.is(encodedURL));
     }
@@ -72,12 +69,9 @@ public class EncoderDecoderUnitTest {
 
         String query = url.getQuery();
 
-        String decodedQuery = Arrays.stream(query.split("&"))
-          .map(param -> param.split("=")[0] + "=" + decode(param.split("=")[1]))
-          .collect(joining("&"));
+        String decodedQuery = Arrays.stream(query.split("&")).map(param -> param.split("=")[0] + "=" + decode(param.split("=")[1])).collect(joining("&"));
 
-        Assert.assertEquals(
-          "http://www.baeldung.com?key1=value 1&key2=value@!$2&key3=value%3", url.getProtocol() + "://" + url.getHost() + "?" + decodedQuery);
+        Assert.assertEquals("http://www.baeldung.com?key1=value 1&key2=value@!$2&key3=value%3", url.getProtocol() + "://" + url.getHost() + "?" + decodedQuery);
     }
 
 }
diff --git a/core-java/src/test/java/com/baeldung/enums/PizzaUnitTest.java b/core-java/src/test/java/com/baeldung/enums/PizzaUnitTest.java
index de60becfce..6cf6ad3551 100644
--- a/core-java/src/test/java/com/baeldung/enums/PizzaUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/enums/PizzaUnitTest.java
@@ -1,6 +1,5 @@
 package com.baeldung.enums;
 
-
 import org.junit.Test;
 
 import java.util.ArrayList;
diff --git a/core-java/src/test/java/com/baeldung/java/networking/udp/UDPIntegrationTest.java b/core-java/src/test/java/com/baeldung/java/networking/udp/UDPIntegrationTest.java
index 2ca2d3a0c8..aff851ae4b 100644
--- a/core-java/src/test/java/com/baeldung/java/networking/udp/UDPIntegrationTest.java
+++ b/core-java/src/test/java/com/baeldung/java/networking/udp/UDPIntegrationTest.java
@@ -1,6 +1,5 @@
 package com.baeldung.java.networking.udp;
 
-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
diff --git a/core-java/src/test/java/com/baeldung/java8/Java8StreamApiUnitTest.java b/core-java/src/test/java/com/baeldung/java8/Java8StreamApiUnitTest.java
index d9a72063af..73a10a57f4 100644
--- a/core-java/src/test/java/com/baeldung/java8/Java8StreamApiUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/java8/Java8StreamApiUnitTest.java
@@ -27,18 +27,14 @@ public class Java8StreamApiUnitTest {
 
     @Before
     public void init() {
-        productList = Arrays.asList(
-                new Product(23, "potatoes"), new Product(14, "orange"),
-                new Product(13, "lemon"), new Product(23, "bread"),
-                new Product(13, "sugar"));
+        productList = Arrays.asList(new Product(23, "potatoes"), new Product(14, "orange"), new Product(13, "lemon"), new Product(23, "bread"), new Product(13, "sugar"));
     }
 
     @Test
     public void checkPipeline_whenStreamOneElementShorter_thenCorrect() {
 
         List<String> list = Arrays.asList("abc1", "abc2", "abc3");
-        long size = list.stream().skip(1)
-                .map(element -> element.substring(0, 3)).count();
+        long size = list.stream().skip(1).map(element -> element.substring(0, 3)).count();
         assertEquals(list.size() - 1, size);
     }
 
@@ -48,11 +44,10 @@ public class Java8StreamApiUnitTest {
         List<String> list = Arrays.asList("abc1", "abc2", "abc3");
 
         counter = 0;
-        long sizeFirst = list.stream()
-                .skip(2).map(element -> {
-                    wasCalled();
-                    return element.substring(0, 3);
-                }).count();
+        long sizeFirst = list.stream().skip(2).map(element -> {
+            wasCalled();
+            return element.substring(0, 3);
+        }).count();
         assertEquals(1, counter);
 
         counter = 0;
@@ -84,7 +79,7 @@ public class Java8StreamApiUnitTest {
         Stream<String> streamOfArray = Stream.of("a", "b", "c");
         assertEquals(3, streamOfArray.count());
 
-        String[] arr = new String[]{"a", "b", "c"};
+        String[] arr = new String[] { "a", "b", "c" };
         Stream<String> streamOfArrayPart = Arrays.stream(arr, 1, 3);
         assertEquals(2, streamOfArrayPart.count());
 
@@ -112,7 +107,7 @@ public class Java8StreamApiUnitTest {
         }
         assertEquals("a", streamOfStrings.findFirst().get());
 
-        Stream<String> streamBuilder = Stream.<String>builder().add("a").add("b").add("c").build();
+        Stream<String> streamBuilder = Stream.<String> builder().add("a").add("b").add("c").build();
         assertEquals(3, streamBuilder.count());
 
         Stream<String> streamGenerated = Stream.generate(() -> "element").limit(10);
@@ -126,14 +121,13 @@ public class Java8StreamApiUnitTest {
     public void runStreamPipeline_whenOrderIsRight_thenCorrect() {
 
         List<String> list = Arrays.asList("abc1", "abc2", "abc3");
-        Optional<String> stream = list.stream()
-                .filter(element -> {
-                    log.info("filter() was called");
-                    return element.contains("2");
-                }).map(element -> {
-                    log.info("map() was called");
-                    return element.toUpperCase();
-                }).findFirst();
+        Optional<String> stream = list.stream().filter(element -> {
+            log.info("filter() was called");
+            return element.contains("2");
+        }).map(element -> {
+            log.info("map() was called");
+            return element.toUpperCase();
+        }).findFirst();
     }
 
     @Test
@@ -145,32 +139,28 @@ public class Java8StreamApiUnitTest {
         int reducedTwoParams = IntStream.range(1, 4).reduce(10, (a, b) -> a + b);
         assertEquals(16, reducedTwoParams);
 
-        int reducedThreeParams = Stream.of(1, 2, 3)
-                .reduce(10, (a, b) -> a + b, (a, b) -> {
-                    log.info("combiner was called");
-                    return a + b;
-                });
+        int reducedThreeParams = Stream.of(1, 2, 3).reduce(10, (a, b) -> a + b, (a, b) -> {
+            log.info("combiner was called");
+            return a + b;
+        });
         assertEquals(16, reducedThreeParams);
 
-        int reducedThreeParamsParallel = Arrays.asList(1, 2, 3).parallelStream()
-                .reduce(10, (a, b) -> a + b, (a, b) -> {
-                    log.info("combiner was called");
-                    return a + b;
-                });
+        int reducedThreeParamsParallel = Arrays.asList(1, 2, 3).parallelStream().reduce(10, (a, b) -> a + b, (a, b) -> {
+            log.info("combiner was called");
+            return a + b;
+        });
         assertEquals(36, reducedThreeParamsParallel);
     }
 
     @Test
     public void collecting_whenAsExpected_thenCorrect() {
 
-        List<String> collectorCollection = productList.stream()
-                .map(Product::getName).collect(Collectors.toList());
+        List<String> collectorCollection = productList.stream().map(Product::getName).collect(Collectors.toList());
 
         assertTrue(collectorCollection instanceof List);
         assertEquals(5, collectorCollection.size());
 
-        String listToString = productList.stream().map(Product::getName)
-                .collect(Collectors.joining(", ", "[", "]"));
+        String listToString = productList.stream().map(Product::getName).collect(Collectors.joining(", ", "[", "]"));
 
         assertTrue(listToString.contains(",") && listToString.contains("[") && listToString.contains("]"));
 
@@ -180,36 +170,29 @@ public class Java8StreamApiUnitTest {
         int summingPrice = productList.stream().collect(Collectors.summingInt(Product::getPrice));
         assertEquals(86, summingPrice);
 
-        IntSummaryStatistics statistics = productList.stream()
-                .collect(Collectors.summarizingInt(Product::getPrice));
+        IntSummaryStatistics statistics = productList.stream().collect(Collectors.summarizingInt(Product::getPrice));
         assertEquals(23, statistics.getMax());
 
-        Map<Integer, List<Product>> collectorMapOfLists = productList.stream()
-                .collect(Collectors.groupingBy(Product::getPrice));
+        Map<Integer, List<Product>> collectorMapOfLists = productList.stream().collect(Collectors.groupingBy(Product::getPrice));
         assertEquals(3, collectorMapOfLists.keySet().size());
 
-        Map<Boolean, List<Product>> mapPartioned = productList.stream()
-                .collect(Collectors.partitioningBy(element -> element.getPrice() > 15));
+        Map<Boolean, List<Product>> mapPartioned = productList.stream().collect(Collectors.partitioningBy(element -> element.getPrice() > 15));
         assertEquals(2, mapPartioned.keySet().size());
 
     }
 
     @Test(expected = UnsupportedOperationException.class)
     public void collect_whenThrows_thenCorrect() {
-        Set<Product> unmodifiableSet = productList.stream()
-                .collect(Collectors.collectingAndThen(Collectors.toSet(),
-                        Collections::unmodifiableSet));
+        Set<Product> unmodifiableSet = productList.stream().collect(Collectors.collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet));
         unmodifiableSet.add(new Product(4, "tea"));
     }
 
     @Test
     public void customCollector_whenResultContainsAllElementsFrSource_thenCorrect() {
-        Collector<Product, ?, LinkedList<Product>> toLinkedList =
-                Collector.of(LinkedList::new, LinkedList::add,
-                        (first, second) -> {
-                            first.addAll(second);
-                            return first;
-                        });
+        Collector<Product, ?, LinkedList<Product>> toLinkedList = Collector.of(LinkedList::new, LinkedList::add, (first, second) -> {
+            first.addAll(second);
+            return first;
+        });
 
         LinkedList<Product> linkedListOfPersons = productList.stream().collect(toLinkedList);
         assertTrue(linkedListOfPersons.containsAll(productList));
@@ -219,23 +202,20 @@ public class Java8StreamApiUnitTest {
     public void parallelStream_whenWorks_thenCorrect() {
         Stream<Product> streamOfCollection = productList.parallelStream();
         boolean isParallel = streamOfCollection.isParallel();
-        boolean haveBigPrice = streamOfCollection.map(product -> product.getPrice() * 12)
-                .anyMatch(price -> price > 200);
+        boolean haveBigPrice = streamOfCollection.map(product -> product.getPrice() * 12).anyMatch(price -> price > 200);
         assertTrue(isParallel && haveBigPrice);
     }
 
     @Test
     public void parallel_whenIsParallel_thenCorrect() {
-        IntStream intStreamParallel =
-                IntStream.range(1, 150).parallel().map(element -> element * 34);
+        IntStream intStreamParallel = IntStream.range(1, 150).parallel().map(element -> element * 34);
         boolean isParallel = intStreamParallel.isParallel();
         assertTrue(isParallel);
     }
 
     @Test
     public void parallel_whenIsSequential_thenCorrect() {
-        IntStream intStreamParallel =
-                IntStream.range(1, 150).parallel().map(element -> element * 34);
+        IntStream intStreamParallel = IntStream.range(1, 150).parallel().map(element -> element * 34);
         IntStream intStreamSequential = intStreamParallel.sequential();
         boolean isParallel = intStreamParallel.isParallel();
         assertFalse(isParallel);
diff --git a/core-java/src/test/java/com/baeldung/java8/Java8StreamsUnitTest.java b/core-java/src/test/java/com/baeldung/java8/Java8StreamsUnitTest.java
index fc83553c6e..e40f9f9506 100644
--- a/core-java/src/test/java/com/baeldung/java8/Java8StreamsUnitTest.java
+++ b/core-java/src/test/java/com/baeldung/java8/Java8StreamsUnitTest.java
@@ -36,7 +36,7 @@ public class Java8StreamsUnitTest {
 
     @Test
     public void checkStreamCount_whenCreating_givenDifferentSources() {
-        String[] arr = new String[]{"a", "b", "c"};
+        String[] arr = new String[] { "a", "b", "c" };
         Stream<String> streamArr = Arrays.stream(arr);
         assertEquals(streamArr.count(), 3);
 
@@ -47,14 +47,12 @@ public class Java8StreamsUnitTest {
         assertEquals(count, 9);
     }
 
-
     @Test
     public void checkStreamCount_whenOperationFilter_thanCorrect() {
         Stream<String> streamFilter = list.stream().filter(element -> element.isEmpty());
         assertEquals(streamFilter.count(), 2);
     }
 
-
     @Test
     public void checkStreamCount_whenOperationMap_thanCorrect() {
         List<String> uris = new ArrayList<>();
@@ -65,12 +63,10 @@ public class Java8StreamsUnitTest {
         List<Detail> details = new ArrayList<>();
         details.add(new Detail());
         details.add(new Detail());
-        Stream<String> streamFlatMap = details.stream()
-                .flatMap(detail -> detail.getParts().stream());
+        Stream<String> streamFlatMap = details.stream().flatMap(detail -> detail.getParts().stream());
         assertEquals(streamFlatMap.count(), 4);
     }
 
-
     @Test
     public void checkStreamCount_whenOperationMatch_thenCorrect() {
         boolean isValid = list.stream().anyMatch(element -> element.contains("h"));
@@ -81,7 +77,6 @@ public class Java8StreamsUnitTest {
         assertFalse(isValidTwo);
     }
 
-
     @Test
     public void checkStreamReducedValue_whenOperationReduce_thenCorrect() {
         List<Integer> integers = new ArrayList<>();
@@ -94,20 +89,17 @@ public class Java8StreamsUnitTest {
 
     @Test
     public void checkStreamContains_whenOperationCollect_thenCorrect() {
-        List<String> resultList = list.stream()
-                .map(element -> element.toUpperCase())
-                .collect(Collectors.toList());
+        List<String> resultList = list.stream().map(element -> element.toUpperCase()).collect(Collectors.toList());
         assertEquals(resultList.size(), list.size());
         assertTrue(resultList.contains(""));
     }
 
-
     @Test
     public void checkParallelStream_whenDoWork() {
         list.parallelStream().forEach(element -> doWork(element));
     }
 
     private void doWork(String string) {
-        assertTrue(true); //just imitate an amount of work
+        assertTrue(true); // just imitate an amount of work
     }
 }
diff --git a/core-java/src/test/java/com/baeldung/threadpool/GuavaThreadPoolIntegrationTest.java b/core-java/src/test/java/com/baeldung/threadpool/GuavaThreadPoolIntegrationTest.java
index fd13a4fd78..550e9dda6f 100644
--- a/core-java/src/test/java/com/baeldung/threadpool/GuavaThreadPoolIntegrationTest.java
+++ b/core-java/src/test/java/com/baeldung/threadpool/GuavaThreadPoolIntegrationTest.java
@@ -46,9 +46,7 @@ public class GuavaThreadPoolIntegrationTest {
         ListenableFuture<String> future1 = listeningExecutorService.submit(() -> "Hello");
         ListenableFuture<String> future2 = listeningExecutorService.submit(() -> "World");
 
-        String greeting = Futures.allAsList(future1, future2).get()
-                .stream()
-                .collect(Collectors.joining(" "));
+        String greeting = Futures.allAsList(future1, future2).get().stream().collect(Collectors.joining(" "));
         assertEquals("Hello World", greeting);
 
     }
diff --git a/core-java/src/test/java/org/baeldung/java/enums/PizzaUnitTest.java b/core-java/src/test/java/org/baeldung/java/enums/PizzaUnitTest.java
index cc042eeca9..bb3abff28d 100644
--- a/core-java/src/test/java/org/baeldung/java/enums/PizzaUnitTest.java
+++ b/core-java/src/test/java/org/baeldung/java/enums/PizzaUnitTest.java
@@ -77,5 +77,5 @@ public class PizzaUnitTest {
         pz.deliver();
         assertTrue(pz.getStatus() == Pizza.PizzaStatusEnum.DELIVERED);
     }
-    
+
 }