pull from master

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/connect4/GameBoard.java

@@ -0,0 +1,129 @@
+package com.baeldung.algorithms.connect4;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class GameBoard {
+    private final List<List<Piece>> columns;
+
+    private final int rows;
+
+    public GameBoard(int columns, int rows) {
+        this.rows = rows;
+        this.columns = new ArrayList<>();
+
+        for (int i = 0; i < columns; ++i) {
+            this.columns.add(new ArrayList<>());
+        }
+    }
+
+    public int getRows() {
+        return rows;
+    }
+
+    public int getColumns() {
+        return columns.size();
+    }
+
+    public Piece getCell(int x, int y) {
+        assert(x >= 0 && x < getColumns());
+        assert(y >= 0 && y < getRows());
+
+        List<Piece> column = columns.get(x);
+
+        if (column.size() > y) {
+            return column.get(y);
+        } else {
+            return null;
+        }
+    }
+
+    public boolean move(int x, Piece player) {
+        assert(x >= 0 && x < getColumns());
+
+        List<Piece> column = columns.get(x);
+
+        if (column.size() >= this.rows) {
+            throw new IllegalArgumentException("That column is full");
+        }
+
+        column.add(player);
+
+        return checkWin(x, column.size() - 1, player);
+    }
+
+    private boolean checkWin(int x, int y, Piece player) {
+        // Vertical line
+        if (checkLine(x, y, 0, -1, player)) {
+            return true;
+        }
+
+        for (int offset = 0; offset < 4; ++offset) {
+            // Horizontal line
+            if (checkLine(x - 3 + offset, y, 1, 0, player)) {
+                return true;
+            }
+
+            // Leading diagonal
+            if (checkLine(x - 3 + offset, y + 3 - offset, 1, -1, player)) {
+                return true;
+            }
+
+            // Trailing diagonal
+            if (checkLine(x - 3 + offset, y - 3 + offset, 1, 1, player)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private boolean checkLine(int x1, int y1, int xDiff, int yDiff, Piece player) {
+        for (int i = 0; i < 4; ++i) {
+            int x = x1 + (xDiff * i);
+            int y = y1 + (yDiff * i);
+
+            if (x < 0 || x > columns.size() - 1) {
+                return false;
+            }
+
+            if (y < 0 || y > rows - 1) {
+                return false;
+            }
+
+            if (player != getCell(x, y)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder result = new StringBuilder();
+
+        for (int y = getRows() - 1; y >= 0; --y) {
+            for (int x = 0; x < getColumns(); ++x) {
+                Piece piece = getCell(x, y);
+
+                result.append("|");
+                if (piece == null) {
+                    result.append(" ");
+                } else if (piece == Piece.PLAYER_1) {
+                    result.append("X");
+                } else if (piece == Piece.PLAYER_2) {
+                    result.append("O");
+                }
+            }
+
+            result.append("|\n");
+            for (int i = 0; i < getColumns(); ++i) {
+                result.append("+-");
+            }
+            result.append("+\n");
+        }
+
+        return result.toString();
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/connect4/GameUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.connect4;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class GameUnitTest {
+    @Test
+    public void blankGame() {
+        GameBoard gameBoard = new GameBoard(8, 6);
+
+        System.out.println(gameBoard);
+    }
+
+    @Test
+    public void playedGame() {
+        GameBoard gameBoard = new GameBoard(8, 6);
+
+        assertFalse(gameBoard.move(3, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(2, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(4, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(3, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(5, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(6, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(5, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(4, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(5, Piece.PLAYER_1));
+        assertFalse(gameBoard.move(5, Piece.PLAYER_2));
+
+        assertFalse(gameBoard.move(6, Piece.PLAYER_1));
+        assertTrue(gameBoard.move(4, Piece.PLAYER_2));
+
+        System.out.println(gameBoard);
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/connect4/Piece.java

@@ -0,0 +1,6 @@
+package com.baeldung.algorithms.connect4;
+
+public enum Piece {
+    PLAYER_1,
+    PLAYER_2
+}

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/connect4/README.md

@@ -0,0 +1,2 @@
+## Relevant Articles
+- [Implement Connect 4 Game with Java](https://www.baeldung.com/java-connect-4-game)

core-java-modules/core-java-8-datetime-2/src/main/java/com/baeldung/rounddate/RoundDate.java

@@ -0,0 +1,113 @@
+package com.baeldung.rounddate;
+
+import java.time.DayOfWeek;
+import java.time.temporal.ChronoField;
+import java.time.temporal.TemporalAdjusters;
+import java.util.Calendar;
+import java.util.Date;
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+
+public class RoundDate {
+    public static Date getDate(int year, int month, int day, int hour, int minute) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.set(Calendar.YEAR, year);
+        calendar.set(Calendar.MONTH, month);
+        calendar.set(Calendar.DAY_OF_MONTH, day);
+        calendar.set(Calendar.HOUR_OF_DAY, hour);
+        calendar.set(Calendar.MINUTE, minute);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+
+        return calendar.getTime();
+    }
+
+    public static Date roundToDay(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.set(Calendar.HOUR_OF_DAY, 0);
+        calendar.set(Calendar.MINUTE, 0);
+        calendar.set(Calendar.SECOND, 0);
+        calendar.set(Calendar.MILLISECOND, 0);
+        return calendar.getTime();
+    }
+
+    public static Date roundToNearestUnit(Date date, int unit) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+
+        switch (unit) {
+            case Calendar.HOUR:
+                int minute = calendar.get(Calendar.MINUTE);
+                if (minute >= 0 && minute < 15) {
+                    calendar.set(Calendar.MINUTE, 0);
+                } else if (minute >= 15 && minute < 45) {
+                    calendar.set(Calendar.MINUTE, 30);
+                } else {
+                    calendar.set(Calendar.MINUTE, 0);
+                    calendar.add(Calendar.HOUR_OF_DAY, 1);
+                }
+                calendar.set(Calendar.SECOND, 0);
+                calendar.set(Calendar.MILLISECOND, 0);
+                break;
+
+            case Calendar.DAY_OF_MONTH:
+                int hour = calendar.get(Calendar.HOUR_OF_DAY);
+                if (hour >= 12) {
+                    calendar.add(Calendar.DAY_OF_MONTH, 1);
+                }
+                calendar.set(Calendar.HOUR_OF_DAY, 0);
+                calendar.set(Calendar.MINUTE, 0);
+                calendar.set(Calendar.SECOND, 0);
+                calendar.set(Calendar.MILLISECOND, 0);
+                break;
+
+            case Calendar.MONTH:
+                int day = calendar.get(Calendar.DAY_OF_MONTH);
+                if (day >= 15) {
+                    calendar.add(Calendar.MONTH, 1);
+                }
+                calendar.set(Calendar.DAY_OF_MONTH, 1);
+                calendar.set(Calendar.HOUR_OF_DAY, 0);
+                calendar.set(Calendar.MINUTE, 0);
+                calendar.set(Calendar.SECOND, 0);
+                calendar.set(Calendar.MILLISECOND, 0);
+                break;
+        }
+
+        return calendar.getTime();
+    }
+
+    public static LocalDateTime roundToStartOfMonthUsingLocalDateTime(LocalDateTime dateTime) {
+        return dateTime.withDayOfMonth(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
+    }
+
+    public static LocalDateTime roundToEndOfWeekUsingLocalDateTime(LocalDateTime dateTime) {
+        return dateTime.with(TemporalAdjusters.next(DayOfWeek.SATURDAY))
+                .withHour(23)
+                .withMinute(59)
+                .withSecond(59)
+                .withNano(999);
+    }
+
+    public static ZonedDateTime roundToStartOfMonthUsingZonedDateTime(ZonedDateTime dateTime) {
+        return dateTime.withDayOfMonth(1)
+                .withHour(0)
+                .withMinute(0)
+                .withSecond(0)
+                .with(ChronoField.MILLI_OF_SECOND, 0)
+                .with(ChronoField.MICRO_OF_SECOND, 0)
+                .with(ChronoField.NANO_OF_SECOND, 0);
+    }
+
+    public static ZonedDateTime roundToEndOfWeekUsingZonedDateTime(ZonedDateTime dateTime) {
+        return dateTime.with(TemporalAdjusters.next(DayOfWeek.SATURDAY))
+                .withHour(23)
+                .withMinute(59)
+                .withSecond(59)
+                .with(ChronoField.MILLI_OF_SECOND, 999)
+                .with(ChronoField.MICRO_OF_SECOND, 999)
+                .with(ChronoField.NANO_OF_SECOND, 999);
+    }
+
+}

core-java-modules/core-java-8-datetime-2/src/test/java/com/baeldung/rounddate/DateRoundingUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.rounddate;
+
+import org.junit.Test;
+
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.Calendar;
+import java.util.Date;
+
+import static org.junit.Assert.assertEquals;
+
+public class DateRoundingUnitTest {
+
+    @Test
+    public void givenDate_whenRoundToDay_thenBeginningOfDay() {
+        Date date = RoundDate.getDate(2023, Calendar.JANUARY, 27, 14, 30);
+        Date result = RoundDate.roundToDay(date);
+        assertEquals(RoundDate.getDate(2023, Calendar.JANUARY, 27, 0, 0), result);
+    }
+
+    @Test
+    public void givenDate_whenRoundToNearestUnit_thenNearestUnit() {
+        Date date = RoundDate.getDate(2023, Calendar.JANUARY, 27, 14, 12);
+        Date result = RoundDate.roundToNearestUnit(date, Calendar.DAY_OF_MONTH);
+        Date expected = RoundDate.getDate(2023, Calendar.JANUARY, 28, 0, 0);
+        assertEquals(expected, result);
+    }
+
+    @Test
+    public void givenLocalDateTime_whenRoundToStartOfMonth_thenStartOfMonth() {
+        LocalDateTime dateTime = LocalDateTime.of(2023, 1, 27, 14, 12);
+        LocalDateTime result = RoundDate.roundToStartOfMonthUsingLocalDateTime(dateTime);
+        LocalDateTime expected = LocalDateTime.of(2023, 1, 1, 0, 0, 0);
+        assertEquals(expected, result);
+    }
+
+
+    @Test
+    public void givenZonedDateTime_whenRoundToStartOfMonth_thenStartOfMonth() {
+        ZonedDateTime dateTime = ZonedDateTime.of(2023, 1, 27, 14, 12, 0, 0, ZoneId.systemDefault());
+        ZonedDateTime result = RoundDate.roundToStartOfMonthUsingZonedDateTime(dateTime);
+        ZonedDateTime expected = ZonedDateTime.of(2023, 1, 1, 0, 0, 0, 0, ZoneId.systemDefault());
+        assertEquals(expected, result);
+    }
+
+    @Test
+    public void givenLocalDateTime_whenRoundToEndOfWeek_thenEndOfWeek() {
+        LocalDateTime dateTime = LocalDateTime.of(2023, 1, 27, 14, 12);
+        LocalDateTime result = RoundDate.roundToEndOfWeekUsingLocalDateTime(dateTime);
+        LocalDateTime expected = LocalDateTime.of(2023, 1, 28, 23, 59, 59, 999);
+        assertEquals(expected, result);
+    }
+
+    @Test
+    public void givenZonedDateTime_whenRoundToEndOfWeek_thenEndOfWeek() {
+        ZonedDateTime dateTime = ZonedDateTime.of(2023, 1, 27, 14, 12, 0, 0, ZoneId.systemDefault());
+        ZonedDateTime result = RoundDate.roundToEndOfWeekUsingZonedDateTime(dateTime);
+        ZonedDateTime expected = ZonedDateTime.of(2023, 1, 28, 23, 59, 59, 999, ZoneId.systemDefault());
+        assertEquals(expected, result);
+    }
+
+}

core-java-modules/core-java-8/src/main/java/com/baeldung/spliterator/CustomSpliterator.java

@@ -0,0 +1,48 @@
+package com.baeldung.spliterator;
+
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+
+public class CustomSpliterator implements Spliterator<Integer> {
+    private final List<Integer> elements;
+    private int currentIndex;
+    
+    public CustomSpliterator(List<Integer> elements) {
+        this.elements = elements;
+        this.currentIndex = 0;
+    }
+    
+    @Override
+    public boolean tryAdvance(Consumer<? super Integer> action) {
+        if (currentIndex < elements.size()) {
+            action.accept(elements.get(currentIndex));
+            currentIndex++;
+            return true;
+        }
+        return false;
+    }
+    
+    @Override
+    public Spliterator<Integer> trySplit() {
+        int currentSize = elements.size() - currentIndex;
+        if (currentSize < 2) {
+            return null;
+        }
+        
+        int splitIndex = currentIndex + currentSize / 2;
+        CustomSpliterator newSpliterator = new CustomSpliterator(elements.subList(currentIndex, splitIndex));
+        currentIndex = splitIndex;
+        return newSpliterator;
+    }
+    
+    @Override
+    public long estimateSize() {
+        return elements.size() - currentIndex;
+    }
+    
+    @Override
+    public int characteristics() {
+        return ORDERED | SIZED | SUBSIZED | NONNULL;
+    }
+} 

core-java-modules/core-java-8/src/main/java/com/baeldung/spliterator/Executor.java

@@ -1,12 +0,0 @@
-package com.baeldung.spliterator;
-
-import java.util.stream.Stream;
-
-public class Executor {
-
-	public static int countAutors(Stream<Author> stream) {
-		RelatedAuthorCounter wordCounter = stream.reduce(new RelatedAuthorCounter(0, true),
-				RelatedAuthorCounter::accumulate, RelatedAuthorCounter::combine);
-		return wordCounter.getCounter();
-	}
-}

core-java-modules/core-java-8/src/main/java/com/baeldung/spliterator/RelatedAuthorCounter.java

@@ -1,27 +0,0 @@
-package com.baeldung.spliterator;
-
-public class RelatedAuthorCounter {
-    private final int counter;
-    private final boolean isRelated;
-
-    public RelatedAuthorCounter(int counter, boolean isRelated) {
-        this.counter = counter;
-        this.isRelated = isRelated;
-    }
-
-    public RelatedAuthorCounter accumulate(Author author) {
-        if (author.getRelatedArticleId() == 0) {
-            return isRelated ? this : new RelatedAuthorCounter(counter, true);
-        } else {
-            return isRelated ? new RelatedAuthorCounter(counter + 1, false) : this;
-        }
-    }
-
-    public RelatedAuthorCounter combine(RelatedAuthorCounter RelatedAuthorCounter) {
-        return new RelatedAuthorCounter(counter + RelatedAuthorCounter.counter, RelatedAuthorCounter.isRelated);
-    }
-
-    public int getCounter() {
-        return counter;
-    }
-}

core-java-modules/core-java-8/src/main/java/com/baeldung/spliterator/RelatedAuthorSpliterator.java

@@ -1,49 +0,0 @@
-package com.baeldung.spliterator;
-
-import java.util.List;
-import java.util.Spliterator;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Consumer;
-
-public class RelatedAuthorSpliterator implements Spliterator<Author> {
-	private final List<Author> list;
-	AtomicInteger current = new AtomicInteger();
-
-	public RelatedAuthorSpliterator(List<Author> list) {
-		this.list = list;
-	}
-
-	@Override
-	public boolean tryAdvance(Consumer<? super Author> action) {
-
-		action.accept(list.get(current.getAndIncrement()));
-		return current.get() < list.size();
-	}
-
-	@Override
-	public Spliterator<Author> trySplit() {
-		int currentSize = list.size() - current.get();
-		if (currentSize < 10) {
-			return null;
-		}
-		for (int splitPos = currentSize / 2 + current.intValue(); splitPos < list.size(); splitPos++) {
-			if (list.get(splitPos).getRelatedArticleId() == 0) {
-				Spliterator<Author> spliterator = new RelatedAuthorSpliterator(list.subList(current.get(), splitPos));
-				current.set(splitPos);
-				return spliterator;
-			}
-		}
-		return null;
-	}
-
-	@Override
-	public long estimateSize() {
-		return list.size() - current.get();
-	}
-
-	@Override
-	public int characteristics() {
-		return CONCURRENT;
-	}
-
-}

core-java-modules/core-java-8/src/test/java/com/baeldung/spliterator/ExecutorUnitTest.java

@@ -6,10 +6,10 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Spliterator;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
 import org.junit.Before;
 import org.junit.Test;
 
@@ -18,22 +18,50 @@ import lombok.extern.slf4j.Slf4j;
 @Slf4j
 public class ExecutorUnitTest {
     Article article;
-    Stream<Author> stream;
-    Spliterator<Author> spliterator;
 
     @Before
     public void init() {
         article = new Article(Arrays.asList(new Author("Ahmad", 0), new Author("Eugen", 0), new Author("Alice", 1), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0),
             new Author("Alice", 1), new Author("Mike", 0), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1),
             new Author("Mike", 0), new Author("Michał", 0), new Author("Loredana", 1)), 0);
-
-        spliterator = new RelatedAuthorSpliterator(article.getListOfAuthors());
     }
 
     @Test
-    public void givenAstreamOfAuthors_whenProcessedInParallelWithCustomSpliterator_coubtProducessRightOutput() {
-        Stream<Author> stream2 = StreamSupport.stream(spliterator, true);
-        assertThat(Executor.countAutors(stream2.parallel())).isEqualTo(9);
+    public void givenAStreamOfIntegers_whenProcessedSequentialCustomSpliterator_countProducesRightOutput() {
+        List<Integer> numbers = new ArrayList<>();
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+        numbers.add(4);
+        numbers.add(5);
+
+        CustomSpliterator customSpliterator = new CustomSpliterator(numbers);
+
+        AtomicInteger sum = new AtomicInteger();
+
+        customSpliterator.forEachRemaining(sum::addAndGet);
+        assertThat(sum.get()).isEqualTo(15);
+    }
+
+    @Test
+    public void givenAStreamOfIntegers_whenProcessedInParallelWithCustomSpliterator_countProducesRightOutput() {
+        List<Integer> numbers = new ArrayList<>();
+        numbers.add(1);
+        numbers.add(2);
+        numbers.add(3);
+        numbers.add(4);
+        numbers.add(5);
+
+        CustomSpliterator customSpliterator = new CustomSpliterator(numbers);
+
+        // Create a ForkJoinPool for parallel processing
+        ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();
+
+        AtomicInteger sum = new AtomicInteger(0);
+
+        // Process elements in parallel using parallelStream
+        forkJoinPool.submit(() -> customSpliterator.forEachRemaining(sum::addAndGet)).join();
+        assertThat(sum.get()).isEqualTo(15);
     }
 
     @Test
@@ -43,9 +71,7 @@ public class ExecutorUnitTest {
             .collect(Collectors.toList());
 
         Spliterator<Article> spliterator = articles.spliterator();
-        while (spliterator.tryAdvance(article -> article.setName(article.getName()
-            .concat("- published by Baeldung"))))
-            ;
+        while(spliterator.tryAdvance(article -> article.setName(article.getName().concat("- published by Baeldung"))));
 
         articles.forEach(article -> assertThat(article.getName()).isEqualTo("Java- published by Baeldung"));
     }

core-java-modules/core-java-collections-5/src/test/java/com/baeldung/vectors/VectorOperationsUnitTest.java

@@ -0,0 +1,87 @@
+package com.baeldung.vectors;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Vector;
+
+import org.junit.Test;
+
+public class VectorOperationsUnitTest {
+
+    private static Vector<String> getVector() {
+        Vector<String> vector = new Vector<String>();
+        vector.add("Today");
+        vector.add("is");
+        vector.add("a");
+        vector.add("great");
+        vector.add("day!");
+
+        return vector;
+    }
+
+    @Test
+    public void givenAVector_whenAddElementsUsingAddMethod_thenElementsGetAddedAtEnd() {
+        Vector<String> vector = getVector();
+        vector.add("Hello");
+        assertEquals(6, vector.size());
+    }
+
+    @Test
+    public void givenAVector_whenUpdateElementAtIndex_thenElementAtIndexGetsUpdated() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+        assertEquals("great", vector.get(3));
+        vector.set(3, "good");
+        assertEquals("good", vector.get(3));
+    }
+
+    @Test
+    public void givenAVector_whenRemoveAnElement_thenElementGetsRemovedFromTheVector() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+
+        // remove a specific element
+        vector.remove("a");
+        assertEquals(4, vector.size());
+
+        // remove at specific index
+        vector.remove(2);
+        assertEquals("day!", vector.get(2));
+        assertEquals(3, vector.size());
+
+        assertEquals(false, vector.remove("SomethingThatDoesn'tExist"));
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void givenAVector_whenIndexIsBeyondRange_thenRemoveMethodThrowsArrayIndexOutOfBoundsException() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+        vector.remove(10);
+    }
+
+    @Test
+    public void givenAVector_whenGetElementWithinARange_thenGetMethodGetsAnElementFromTheVector() {
+        Vector<String> vector = getVector();
+        String fourthElement = vector.get(3);
+        assertEquals("great", fourthElement);
+    }
+
+    @Test(expected = ArrayIndexOutOfBoundsException.class)
+    public void givenAVector_whenGetElementBeyondARange_thenGetMethodThrowsArrayIndexOutOfBoundsException() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+        vector.get(10);
+    }
+
+    @Test
+    public void givenAVector_whenAddElementFromACollection_thenAllElementsGetAdeddToTheVector() {
+        Vector<String> vector = getVector();
+        assertEquals(5, vector.size());
+        ArrayList<String> words = new ArrayList<>(Arrays.asList("Baeldung", "is", "cool!"));
+        vector.addAll(words);
+        assertEquals(8, vector.size());
+        assertEquals("cool!", vector.get(7));
+    }
+}

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

@@ -79,5 +79,18 @@
             <version>1.5</version>
         </dependency>
     </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <argLine>
+                        --add-opens java.base/java.util=ALL-UNNAMED
+                    </argLine>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
 
 </project>

core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/linkedhashmapfirstandlastentry/GetFirstAndLastEntryFromLinkedHashMapUnitTest.java

@@ -0,0 +1,85 @@
+package com.baeldung.map.linkedhashmapfirstandlastentry;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map.Entry;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class GetFirstAndLastEntryFromLinkedHashMapUnitTest {
+    private static final LinkedHashMap<String, String> THE_MAP = new LinkedHashMap<>();
+
+    static {
+        THE_MAP.put("key one", "a1 b1 c1");
+        THE_MAP.put("key two", "a2 b2 c2");
+        THE_MAP.put("key three", "a3 b3 c3");
+        THE_MAP.put("key four", "a4 b4 c4");
+    }
+
+    @Test
+    void whenIteratingEntrySet_thenGetExpectedResult() {
+        Entry<String, String> firstEntry = THE_MAP.entrySet().iterator().next();
+        assertEquals("key one", firstEntry.getKey());
+        assertEquals("a1 b1 c1", firstEntry.getValue());
+
+        Entry<String, String> lastEntry = null;
+        Iterator<Entry<String, String>> it = THE_MAP.entrySet().iterator();
+        while (it.hasNext()) {
+            lastEntry = it.next();
+        }
+
+        assertNotNull(lastEntry);
+        assertEquals("key four", lastEntry.getKey());
+        assertEquals("a4 b4 c4", lastEntry.getValue());
+
+    }
+
+    @Test
+    void whenConvertingEntriesToArray_thenGetExpectedResult() {
+
+        Entry<String, String>[] theArray = new Entry[THE_MAP.size()];
+        THE_MAP.entrySet().toArray(theArray);
+
+        Entry<String, String> firstEntry = theArray[0];
+        assertEquals("key one", firstEntry.getKey());
+        assertEquals("a1 b1 c1", firstEntry.getValue());
+
+        Entry<String, String> lastEntry = theArray[THE_MAP.size() - 1];
+        assertEquals("key four", lastEntry.getKey());
+        assertEquals("a4 b4 c4", lastEntry.getValue());
+    }
+
+    @Test
+    void whenUsingStreamAPI_thenGetExpectedResult() {
+        Entry<String, String> firstEntry = THE_MAP.entrySet().stream().findFirst().get();
+        assertEquals("key one", firstEntry.getKey());
+        assertEquals("a1 b1 c1", firstEntry.getValue());
+
+        Entry<String, String> lastEntry = THE_MAP.entrySet().stream().skip(THE_MAP.size() - 1).findFirst().get();
+
+        assertNotNull(lastEntry);
+        assertEquals("key four", lastEntry.getKey());
+        assertEquals("a4 b4 c4", lastEntry.getValue());
+    }
+
+    @Test
+    void whenUsingReflection_thenGetExpectedResult() throws NoSuchFieldException, IllegalAccessException {
+        Field head = THE_MAP.getClass().getDeclaredField("head");
+        head.setAccessible(true);
+        Entry<String, String> firstEntry = (Entry<String, String>) head.get(THE_MAP);
+        assertEquals("key one", firstEntry.getKey());
+        assertEquals("a1 b1 c1", firstEntry.getValue());
+
+        Field tail = THE_MAP.getClass().getDeclaredField("tail");
+        tail.setAccessible(true);
+        Entry<String, String> lastEntry = (Entry<String, String>) tail.get(THE_MAP);
+        assertEquals("key four", lastEntry.getKey());
+        assertEquals("a4 b4 c4", lastEntry.getValue());
+    }
+
+
+}

core-java-modules/core-java-concurrency-basic-3/README.md

@@ -11,4 +11,5 @@ This module contains articles about basic Java concurrency.
 - [CompletableFuture and ThreadPool in Java](https://www.baeldung.com/java-completablefuture-threadpool)
 - [CompletableFuture allOf().join() vs. CompletableFuture.join()](https://www.baeldung.com/java-completablefuture-allof-join)
 - [Retry Logic with CompletableFuture](https://www.baeldung.com/java-completablefuture-retry-logic)
+- [Convert From List of CompletableFuture to CompletableFuture List](https://www.baeldung.com/java-completablefuture-list-convert)
 - [[<-- Prev]](../core-java-concurrency-basic-2)

core-java-modules/core-java-documentation/src/main/java/com/baeldung/generictype/Pair.java

@@ -0,0 +1,23 @@
+package com.baeldung.generictype;
+
+/**
+ * @param <T> The type of the first value in the {@code Pair<T,S>}.
+ * @param <S> The type of the second value in the {@code Pair<T,S>}.
+ */
+
+public class Pair<T, S> {
+    public T first;
+    public S second;
+
+    /**
+     * Constructs a new Pair object with the specified values.
+     *
+     * @param a The first value.
+     * @param b The second value.
+     */
+
+    public Pair(T a, S b) {
+        first = a;
+        second = b;
+    }
+}

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

@@ -5,5 +5,6 @@ This module contains articles about core Java input and output (IO)
 ### Relevant Articles: 
 - [Get File Extension From MIME Type in Java](https://www.baeldung.com/java-mime-type-file-extension)
 - [How to Remove Line Breaks From a File in Java](https://www.baeldung.com/java-file-remove-line-breaks)
+- [Difference Between ZipFile and ZipInputStream in Java](https://www.baeldung.com/java-zipfile-vs-zipinputstream)
 - [[<-- Prev]](/core-java-modules/core-java-io-4)
 

core-java-modules/core-java-io-apis-2/README.md

@@ -8,3 +8,4 @@ This module contains articles about core Java input/output(IO) APIs.
 - [Check if a File Is Empty in Java](https://www.baeldung.com/java-check-file-empty)
 - [Converting Relative to Absolute Paths in Java](https://www.baeldung.com/java-from-relative-to-absolute-paths)
 - [Detect EOF in Java](https://www.baeldung.com/java-file-detect-end-of-file)
+- [PrintWriter vs. FileWriter in Java](https://www.baeldung.com/java-printwriter-filewriter-difference)

core-java-modules/core-java-io-conversions-2/pom.xml

@@ -56,7 +56,7 @@
         <source.version>11</source.version>
         <target.version>11</target.version>
         <json.version>20200518</json.version>
-        <opencsv.version>4.1</opencsv.version>
+        <opencsv.version>5.8</opencsv.version>
     </properties>
 
 </project>

core-java-modules/core-java-jndi/src/test/java/com/baeldung/jndi/JndiNamingUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.jndi;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.jndi.JndiTemplate;
+import org.springframework.mock.jndi.SimpleNamingContextBuilder;
+
+import javax.naming.*;
+import javax.sql.DataSource;
+
+import java.util.Enumeration;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class JndiNamingUnitTest {
+
+    private static InitialContext context;
+    private static DriverManagerDataSource dataSource;
+
+    @BeforeAll
+    static void setUp() throws Exception {
+        SimpleNamingContextBuilder builder = new SimpleNamingContextBuilder();
+        dataSource = new DriverManagerDataSource("jdbc:h2:mem:mydb");
+        builder.activate();
+
+        JndiTemplate jndiTemplate = new JndiTemplate();
+        context = (InitialContext) jndiTemplate.getContext();
+        
+        dataSource.setDriverClassName("org.h2.Driver");
+        context.bind("java:comp/env/jdbc/datasource", dataSource);
+    }
+
+    @Test
+    void givenACompositeName_whenAddingAnElement_thenNameIsAdded() throws Exception {
+        Name objectName = new CompositeName("java:comp/env/jdbc");
+
+        Enumeration<String> items = objectName.getAll();
+        while(items.hasMoreElements()) {
+            System.out.println(items.nextElement());
+        }
+
+        objectName.add("New Name");
+
+        assertEquals("env", objectName.get(1));
+        assertEquals("New Name", objectName.get(objectName.size() - 1));
+    }
+
+    @Test
+    void givenContext_whenLookupByName_thenReturnsValidObject() throws Exception {
+        DataSource ds = (DataSource) context.lookup("java:comp/env/jdbc/datasource");
+
+        assertNotNull(ds);
+        assertNotNull(ds.getConnection());
+    }
+    
+    @Test
+    void givenSubContext_whenLookupByName_thenReturnsValidObject() throws Exception {
+        Context subContext = (Context) context.lookup("java:comp/env");
+        DataSource ds = (DataSource) subContext.lookup("jdbc/datasource");
+
+        assertNotNull(ds);
+        assertNotNull(ds.getConnection());
+    }
+    
+    @AfterAll
+    static void tearDown() throws Exception {
+       context.close();
+    }
+
+}

core-java-modules/core-java-numbers-6/src/test/java/com/baeldung/genericnumberscomparator/GenericNumbersComparatorUnitTest.java

@@ -0,0 +1,122 @@
+package com.baeldung.genericnumberscomparator;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.function.BiPredicate;
+import java.util.function.Function;
+
+import org.junit.jupiter.api.Test;
+
+class GenericNumbersComparatorUnitTest {
+
+    public int compareDouble(Number num1, Number num2) {
+        return Double.compare(num1.doubleValue(), num2.doubleValue());
+    }
+
+    @Test
+    void givenNumbers_whenUseCompareDouble_thenWillExecuteComparison() {
+        assertEquals(0, compareDouble(5, 5.0));
+    }
+
+    public int compareTo(Integer int1, Integer int2) {
+        return int1.compareTo(int2);
+    }
+
+    @Test
+    void givenNumbers_whenUseCompareTo_thenWillExecuteComparison() {
+        assertEquals(-1, compareTo(5, 7));
+    }
+
+    Map<Class<? extends Number>, BiFunction<Number, Number, Integer>> comparisonMap = new HashMap<>();
+
+    public int compareUsingMap(Number num1, Number num2) {
+        comparisonMap.put(Integer.class, (a, b) -> ((Integer) num1).compareTo((Integer) num2));
+
+        return comparisonMap.get(num1.getClass())
+            .apply(num1, num2);
+    }
+
+    @Test
+    void givenNumbers_whenUseCompareUsingMap_thenWillExecuteComparison() {
+        assertEquals(-1, compareUsingMap(5, 7));
+    }
+
+    public interface NumberComparator {
+        int compare(Number num1, Number num2);
+    }
+
+    @Test
+    void givenNumbers_whenUseProxy_thenWillExecuteComparison() {
+        NumberComparator proxy = (NumberComparator) Proxy.newProxyInstance(NumberComparator.class.getClassLoader(), new Class[] { NumberComparator.class },
+            (p, method, args) -> Double.compare(((Number) args[0]).doubleValue(), ((Number) args[1]).doubleValue()));
+        assertEquals(0, proxy.compare(5, 5.0));
+    }
+
+    public int compareUsingReflection(Number num1, Number num2) throws Exception {
+        Method method = num1.getClass()
+            .getMethod("compareTo", num1.getClass());
+        return (int) method.invoke(num1, num2);
+    }
+
+    @Test
+    void givenNumbers_whenUseCompareUsingReflection_thenWillExecuteComparison() throws Exception {
+        assertEquals(-1, compareUsingReflection(5, 7));
+    }
+
+    interface NumberComparatorFactory {
+        Comparator<Number> getComparator();
+    }
+
+    class IntegerComparatorFactory implements NumberComparatorFactory {
+        @Override
+        public Comparator<Number> getComparator() {
+            return (num1, num2) -> ((Integer) num1).compareTo((Integer) num2);
+        }
+    }
+
+    @Test
+    void givenNumbers_whenUseComparatorFactory_thenWillExecuteComparison() {
+        NumberComparatorFactory factory = new IntegerComparatorFactory();
+        Comparator<Number> comparator = factory.getComparator();
+        assertEquals(-1, comparator.compare(5, 7));
+    }
+
+    Function<Number, Double> toDouble = Number::doubleValue;
+    BiPredicate<Number, Number> isEqual = (num1, num2) -> toDouble.apply(num1)
+        .equals(toDouble.apply(num2));
+
+    @Test
+    void givenNumbers_whenUseIsEqual_thenWillExecuteComparison() {
+        assertEquals(true, isEqual.test(5, 5.0));
+    }
+
+    private Number someNumber = 5;
+    private Number anotherNumber = 5.0;
+
+    Optional<Number> optNum1 = Optional.ofNullable(someNumber);
+    Optional<Number> optNum2 = Optional.ofNullable(anotherNumber);
+    int comparisonResult = optNum1.flatMap(n1 -> optNum2.map(n2 -> Double.compare(n1.doubleValue(), n2.doubleValue())))
+        .orElse(0);
+
+    @Test
+    void givenNumbers_whenUseComparisonResult_thenWillExecuteComparison() {
+        assertEquals(0, comparisonResult);
+    }
+
+    private boolean someCondition = true;
+    Function<Number, ?> dynamicFunction = someCondition ? Number::doubleValue : Number::intValue;
+    Comparator<Number> dynamicComparator = (num1, num2) -> ((Comparable) dynamicFunction.apply(num1)).compareTo(dynamicFunction.apply(num2));
+
+    @Test
+    void givenNumbers_whenUseDynamicComparator_thenWillExecuteComparison() {
+        assertEquals(0, dynamicComparator.compare(5, 5.0));
+    }
+
+}

core-java-modules/core-java-records/src/main/java/com/baeldung/optionalsasparameterrecords/Product.java

@@ -0,0 +1,6 @@
+package com.baeldung.optionalsasparameterrecords;
+
+import java.util.Optional;
+
+public record Product(String name, double price, Optional<String> description) {
+}

core-java-modules/core-java-records/src/test/java/com/baeldung/optionalsasparameterrecords/OptionalAsRecordParameterUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.optionalsasparameterrecords;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+public class OptionalAsRecordParameterUnitTest {
+
+    @Test
+    public void givenRecordCreationWithOptional_thenCreateItProperly() {
+        var emptyDescriptionProduct = new Product("television", 1699.99, Optional.empty());
+        Assertions.assertEquals("television", emptyDescriptionProduct.name());
+        Assertions.assertEquals(1699.99, emptyDescriptionProduct.price());
+        Assertions.assertNull(emptyDescriptionProduct.description().orElse(null));
+    }
+}

core-java-modules/core-java-regex-2/src/main/java/com/baeldung/alphanumeric/AlphanumericPerformanceBenchmark.java

@@ -85,7 +85,7 @@ public class AlphanumericPerformanceBenchmark {
 
     public boolean isAlphanumeric(final int codePoint) {
         return (codePoint >= 65 && codePoint <= 90) ||
-               (codePoint >= 97 && codePoint <= 172) ||
+               (codePoint >= 97 && codePoint <= 122) ||
                (codePoint >= 48 && codePoint <= 57);
     }
 }

core-java-modules/core-java-streams-5/src/test/java/com/baeldung/streamtomapandmultimap/StreamToMapAndMultiMapUnitTest.java

@@ -0,0 +1,100 @@
+package com.baeldung.streamtomapandmultimap;
+
+import com.google.common.collect.LinkedHashMultimap;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+
+public class StreamToMapAndMultiMapUnitTest {
+    @Test
+    public void givenStringStream_whenConvertingToMapWithMerge_thenExpectedMapIsGenerated() {
+        Stream<String> stringStream = Stream.of("one", "two", "three", "two");
+
+        Map<String, String> mergedMap = stringStream.collect(
+                Collectors.toMap(s -> s, s -> s, (s1, s2) -> s1 + ", " + s2)
+        );
+
+        // Define the expected map
+        Map<String, String> expectedMap = Map.of(
+                "one", "one",
+                "two", "two, two",
+                "three", "three"
+        );
+
+        assertEquals(expectedMap, mergedMap);
+    }
+
+    @Test
+    public void givenStringStream_whenConvertingToMultimap_thenExpectedMultimapIsGenerated() {
+        Stream<String> stringStream = Stream.of("one", "two", "three", "two");
+
+        LinkedHashMultimap<Object, Object> multimap = LinkedHashMultimap.create();
+
+        stringStream.collect(Collectors.groupingBy(
+                s -> s,
+                Collectors.mapping(s -> s, Collectors.toList())
+        )).forEach((key, value) -> multimap.putAll(key, value));
+
+        LinkedHashMultimap<Object, Object> expectedMultimap = LinkedHashMultimap.create();
+        expectedMultimap.put("one", "one");
+        expectedMultimap.put("two", "two");
+        expectedMultimap.put("three", "three");
+
+        assertEquals(expectedMultimap, multimap);
+    }
+
+    @Test
+    public void givenStringStream_whenConvertingToMultimapWithStreamReduce_thenExpectedMultimapIsGenerated() {
+        Stream<String> stringStream = Stream.of("one", "two", "three", "two");
+
+        Map<String, List<String>> multimap = stringStream.reduce(
+                new HashMap<>(),
+                (map, element) -> {
+                    map.computeIfAbsent(element, k -> new ArrayList<>()).add(element);
+                    return map;
+                },
+                (map1, map2) -> {
+                    map2.forEach((key, value) -> map1.merge(key, value, (list1, list2) -> {
+                        list1.addAll(list2);
+                        return list1;
+                    }));
+                    return map1;
+                }
+        );
+
+        Map<String, List<String>> expectedMultimap = new HashMap<>();
+        expectedMultimap.put("one", Collections.singletonList("one"));
+        expectedMultimap.put("two", Arrays.asList("two", "two"));
+        expectedMultimap.put("three", Collections.singletonList("three"));
+
+        assertEquals(expectedMultimap, multimap);
+    }
+
+    @Test
+    public void givenStringStream_whenConvertingToMapWithStreamReduce_thenExpectedMapIsGenerated() {
+        Stream<String> stringStream = Stream.of("one", "two", "three", "two");
+
+        Map<String, String> resultMap = stringStream.reduce(
+                new HashMap<>(),
+                (map, element) -> {
+                    map.put(element, element);
+                    return map;
+                },
+                (map1, map2) -> {
+                    map1.putAll(map2);
+                    return map1;
+                }
+        );
+
+        Map<String, String> expectedMap = new HashMap<>();
+        expectedMap.put("one", "one");
+        expectedMap.put("two", "two");
+        expectedMap.put("three", "three");
+
+        assertEquals(expectedMap, resultMap);
+    }
+}

core-java-modules/core-java-streams-simple/src/test/java/com/baeldung/streams/Java8StreamsUnitTest.java

@@ -1,7 +1,11 @@
 package com.baeldung.streams;
 
-import org.junit.Before;
-import org.junit.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
 
 import java.nio.file.Path;
 import java.nio.file.Paths;
@@ -11,14 +15,12 @@ import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static org.junit.Assert.*;
+class Java8StreamsUnitTest {
 
-public class Java8StreamsUnitTest {
+    private static List<String> list;
 
-    private List<String> list;
-
-    @Before
-    public void init() {
+    @BeforeAll
+    public static void init() {
         list = new ArrayList<>();
         list.add("One");
         list.add("OneAndOnly");
@@ -42,60 +44,73 @@ public class Java8StreamsUnitTest {
         Stream<String> streamOf = Stream.of("a", "b", "c");
         assertEquals(streamOf.count(), 3);
 
-        long count = list.stream().distinct().count();
+        long count = list.stream()
+            .distinct()
+            .count();
         assertEquals(count, 9);
     }
 
     @Test
-    public void checkStreamCount_whenOperationFilter_thanCorrect() {
-        Stream<String> streamFilter = list.stream().filter(element -> element.isEmpty());
+    void checkStreamCount_whenOperationFilter_thanCorrect() {
+        Stream<String> streamFilter = list.stream()
+            .filter(element -> element.isEmpty());
         assertEquals(streamFilter.count(), 2);
     }
 
     @Test
-    public void checkStreamCount_whenOperationMap_thanCorrect() {
+    void checkStreamCount_whenOperationMap_thanCorrect() {
         List<String> uris = new ArrayList<>();
         uris.add("C:\\My.txt");
-        Stream<Path> streamMap = uris.stream().map(uri -> Paths.get(uri));
+        Stream<Path> streamMap = uris.stream()
+            .map(uri -> Paths.get(uri));
         assertEquals(streamMap.count(), 1);
 
         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"));
-        boolean isValidOne = list.stream().allMatch(element -> element.contains("h"));
-        boolean isValidTwo = list.stream().noneMatch(element -> element.contains("h"));
+    void checkStreamCount_whenOperationMatch_thenCorrect() {
+        boolean isValid = list.stream()
+            .anyMatch(element -> element.contains("h"));
+        boolean isValidOne = list.stream()
+            .allMatch(element -> element.contains("h"));
+        boolean isValidTwo = list.stream()
+            .noneMatch(element -> element.contains("h"));
         assertTrue(isValid);
         assertFalse(isValidOne);
         assertFalse(isValidTwo);
     }
 
     @Test
-    public void checkStreamReducedValue_whenOperationReduce_thenCorrect() {
+    void checkStreamReducedValue_whenOperationReduce_thenCorrect() {
         List<Integer> integers = new ArrayList<>();
         integers.add(1);
         integers.add(1);
         integers.add(1);
-        Integer reduced = integers.stream().reduce(23, (a, b) -> a + b);
+        Integer reduced = integers.stream()
+            .reduce(23, (a, b) -> a + b);
         assertTrue(reduced == 26);
     }
 
     @Test
-    public void checkStreamContains_whenOperationCollect_thenCorrect() {
-        List<String> resultList = list.stream().map(element -> element.toUpperCase()).collect(Collectors.toList());
+    void checkStreamContains_whenOperationCollect_thenCorrect() {
+        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));
+        list.parallelStream()
+            .forEach(element -> doWork(element));
     }
 
     private void doWork(String string) {

core-java-modules/core-java-string-apis-2/src/test/java/com/baeldung/nthsubstring/FindNthSubstringIndexUnitTest.java

@@ -0,0 +1,106 @@
+package com.baeldung.nthsubstring;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class FindNthSubstringIndexUnitTest {
+    //                                  "0       8       16      24    "
+    private final static String INPUT = "a word, a word, a word, a word";
+
+    @Test
+    void whenCallingIndexOfTwice_thenGetTheSecondSubstringIndex() {
+        int firstIdx = INPUT.indexOf("a");
+        int result = INPUT.indexOf("a", firstIdx + "a".length());
+        assertEquals(8, result);
+    }
+
+    // the recursive approach
+    static int nthIndexOf(String input, String substring, int nth) {
+        if (nth == 1) {
+            return input.indexOf(substring);
+        } else {
+            return input.indexOf(substring, nthIndexOf(input, substring, nth - 1) + substring.length());
+        }
+    }
+
+    @Test
+    void whenCallingRecursiveMethod_thenGetTheExpectedResult() {
+        int result1 = nthIndexOf(INPUT, "a", 1);
+        assertEquals(0, result1);
+
+        int result2 = nthIndexOf(INPUT, "a", 2);
+        assertEquals(8, result2);
+
+        int result3 = nthIndexOf(INPUT, "a", 3);
+        assertEquals(16, result3);
+
+        int result4 = nthIndexOf(INPUT, "a", 4);
+        assertEquals(24, result4);
+
+        int result5 = nthIndexOf(INPUT, "a", 5);
+        assertEquals(-1, result5);
+    }
+
+    // loop-based approach
+    static int nthIndexOf2(String input, String substring, int nth) {
+        int index = -1;
+        while (nth > 0) {
+            index = input.indexOf(substring, index + substring.length());
+            if (index == -1) {
+                return -1;
+            }
+            nth--;
+        }
+        return index;
+    }
+
+    @Test
+    void whenCallingLoopBasedMethod_thenGetTheExpectedResult() {
+        int result1 = nthIndexOf2(INPUT, "a", 1);
+        assertEquals(0, result1);
+
+        int result2 = nthIndexOf2(INPUT, "a", 2);
+        assertEquals(8, result2);
+
+        int result3 = nthIndexOf2(INPUT, "a", 3);
+        assertEquals(16, result3);
+
+        int result4 = nthIndexOf2(INPUT, "a", 4);
+        assertEquals(24, result4);
+
+        int result5 = nthIndexOf2(INPUT, "a", 5);
+        assertEquals(-1, result5);
+    }
+
+    static int nthOccurrenceIndex(String input, String regexPattern, int nth) {
+        Matcher matcher = Pattern.compile(regexPattern).matcher(INPUT);
+        for (int i = 0; i < nth; i++) {
+            if (!matcher.find()) {
+                return -1;
+            }
+        }
+        return matcher.start();
+    }
+
+    @Test
+    void whenCallingRegexBasedMethod_thenGetTheExpectedResult() {
+        int result1 = nthOccurrenceIndex(INPUT, "a", 1);
+        assertEquals(0, result1);
+
+        int result2 = nthOccurrenceIndex(INPUT, "a", 2);
+        assertEquals(8, result2);
+
+        int result3 = nthOccurrenceIndex(INPUT, "a", 3);
+        assertEquals(16, result3);
+
+        int result4 = nthOccurrenceIndex(INPUT, "a", 4);
+        assertEquals(24, result4);
+
+        int result5 = nthOccurrenceIndex(INPUT, "a", 5);
+        assertEquals(-1, result5);
+    }
+}

core-java-modules/core-java-string-operations-2/pom.xml

@@ -54,6 +54,11 @@
             <artifactId>commons-codec</artifactId>
             <version>${commons-codec.version}</version>
         </dependency>
+        <dependency> 
+            <groupId>org.springframework</groupId> 
+            <artifactId>spring-core</artifactId> 
+            <version>${spring-core.version}</version> 
+        </dependency>
     </dependencies>
 
     <build>
@@ -95,6 +100,7 @@
         <javax.el-api.version>3.0.0</javax.el-api.version>
         <javax.el.version>2.2.6</javax.el.version>
         <commons-codec.version>1.14</commons-codec.version>
+        <spring-core.version>5.3.0</spring-core.version>
     </properties>
 
 </project>

core-java-modules/core-java-string-operations-2/src/test/java/com/baeldung/emptystrings/EmptyStringsUnitTest.java

@@ -3,6 +3,7 @@ package com.baeldung.emptystrings;
 import com.google.common.base.Strings;
 import org.apache.commons.lang3.StringUtils;
 import org.junit.Test;
+import org.springframework.util.ObjectUtils;
 
 import javax.validation.ConstraintViolation;
 import javax.validation.Validation;
@@ -109,6 +110,24 @@ public class EmptyStringsUnitTest {
         assertFalse(Strings.isNullOrEmpty(blankString));
     }
 
+    /*
+     * Spring Core ObjectUtils
+     */
+    @Test
+    public void givenSomeEmptyString_thenObjectUtilsIsEmptyReturnsTrue() {
+        assertTrue(ObjectUtils.isEmpty(emptyString));
+    }
+
+    @Test
+    public void givenSomeNonEmptyString_thenObjectUtilsIsEmptyReturnsFalse() {
+        assertFalse(ObjectUtils.isEmpty(nonEmptyString));
+    }
+
+    @Test
+    public void givenSomeBlankString_thenObjectUtilsIsEmptyReturnsFalse() {
+        assertFalse(ObjectUtils.isEmpty(blankString));
+    }
+
     /*
      * Bean Validation
      */

core-java-modules/core-java-string-operations-4/pom.xml

@@ -58,7 +58,7 @@
     <properties>
         <maven.compiler.source>11</maven.compiler.source>
         <maven.compiler.target>11</maven.compiler.target>
-        <opencsv.version>4.1</opencsv.version>
+        <opencsv.version>5.8</opencsv.version>
         <spring-core.version>5.3.13</spring-core.version>
         <apache-commons-lang3.version>3.12.0</apache-commons-lang3.version>
         <apache-commons-text.version>1.10.0</apache-commons-text.version>

core-java-modules/core-java-string-operations-4/src/main/java/com/baeldung/commaseparatedstring/SplitCommaSeparatedString.java

@@ -12,6 +12,7 @@ import com.opencsv.CSVParser;
 import com.opencsv.CSVParserBuilder;
 import com.opencsv.CSVReader;
 import com.opencsv.CSVReaderBuilder;
+import com.opencsv.exceptions.CsvException;
 
 public class SplitCommaSeparatedString {
 
@@ -50,7 +51,7 @@ public class SplitCommaSeparatedString {
         return splitter.splitToList(input);
     }
 
-    public static List<String[]> splitMultiLineWithOpenCSV(String input) throws IOException {
+    public static List<String[]> splitMultiLineWithOpenCSV(String input) throws IOException, CsvException {
         CSVParser parser = new CSVParserBuilder().withSeparator(',')
             .build();
 

core-java-modules/core-java-string-operations-4/src/test/java/com/baeldung/commaseparatedstring/SplitCommaSeparatedStringUnitTest.java

@@ -14,6 +14,8 @@ import java.util.List;
 
 import org.junit.Test;
 
+import com.opencsv.exceptions.CsvException;
+
 public class SplitCommaSeparatedStringUnitTest {
     
     @Test
@@ -27,7 +29,7 @@ public class SplitCommaSeparatedStringUnitTest {
     }
     
     @Test
-    public void givenMultiLineInput_whenParsing_shouldIgnoreCommasInsideDoubleQuotes() throws IOException {
+    public void givenMultiLineInput_whenParsing_shouldIgnoreCommasInsideDoubleQuotes() throws IOException, CsvException {
         String input = "baeldung,tutorial,splitting,text,\"ignoring this comma,\"" + System.lineSeparator()
         + "splitting,a,regular,line,no double quotes";
 

core-java-modules/core-java-string-operations-7/src/main/java/com/baeldung/mutablestrings/CharsetUsageExample.java

@@ -0,0 +1,34 @@
+package com.baeldung.mutablestrings;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+
+public class CharsetUsageExample {
+
+    public ByteBuffer encodeString(String inputString) {
+        Charset charset = Charset.forName("UTF-8");
+        CharsetEncoder encoder = charset.newEncoder();
+
+        CharBuffer charBuffer = CharBuffer.wrap(inputString);
+        ByteBuffer byteBuffer = ByteBuffer.allocate(50);
+
+        encoder.encode(charBuffer, byteBuffer, true); // true indicates the end of input
+        byteBuffer.flip();
+        return byteBuffer;
+    }
+
+    public String decodeString(ByteBuffer byteBuffer) {
+        Charset charset = Charset.forName("UTF-8");
+        CharsetDecoder decoder = charset.newDecoder();
+        CharBuffer decodedCharBuffer = CharBuffer.allocate(50);
+        decoder.decode(byteBuffer, decodedCharBuffer, true);
+        decodedCharBuffer.flip();
+
+        return decodedCharBuffer.toString();
+    }
+}

core-java-modules/core-java-string-operations-7/src/main/java/com/baeldung/mutablestrings/MutableStringUsingCharset.java

@@ -0,0 +1,65 @@
+package com.baeldung.mutablestrings;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+import java.util.concurrent.atomic.AtomicReference;
+
+public class MutableStringUsingCharset {
+
+    private final AtomicReference<CharBuffer> cbRef = new AtomicReference<>();
+    private final Charset myCharset = new Charset("mycharset", null) {
+        @Override
+        public boolean contains(Charset cs) {
+            return false;
+        }
+
+        @Override
+        public CharsetDecoder newDecoder() {
+            return new CharsetDecoder(this, 1.0f, 1.0f) {
+                @Override
+                protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {
+                    cbRef.set(out);
+                    while (in.remaining() > 0) {
+                        out.append((char) in.get());
+                    }
+                    return CoderResult.UNDERFLOW;
+                }
+            };
+        }
+
+        @Override
+        public CharsetEncoder newEncoder() {
+            CharsetEncoder cd = new CharsetEncoder(this, 1.0f, 1.0f) {
+                @Override
+                protected CoderResult encodeLoop(CharBuffer in, ByteBuffer out) {
+                    while (in.hasRemaining()) {
+                        if (!out.hasRemaining()) {
+                            return CoderResult.OVERFLOW;
+                        }
+                        char currentChar = in.get();
+                        if (currentChar > 127) {
+                            return CoderResult.unmappableForLength(1);
+                        }
+                        out.put((byte) currentChar);
+                    }
+                    return CoderResult.UNDERFLOW;
+                }
+            };
+            return cd;
+        }
+    };
+
+    public String createModifiableString(String s) {
+        return new String(s.getBytes(), myCharset);
+    }
+
+    public void modifyString() {
+        CharBuffer cb = cbRef.get();
+        cb.position(0);
+        cb.put("xyz");
+    }
+}

core-java-modules/core-java-string-operations-7/src/main/java/com/baeldung/mutablestrings/MutableStrings.java

@@ -0,0 +1,24 @@
+package com.baeldung.mutablestrings;
+
+import java.lang.reflect.Field;
+import java.nio.charset.Charset;
+
+import com.google.errorprone.annotations.DoNotCall;
+
+public class MutableStrings {
+
+    /**
+     * This involves using Reflection to change String fields and it is not encouraged to use this in programs.
+     * @throws NoSuchFieldException
+     * @throws IllegalAccessException
+     */
+    @DoNotCall
+    public void mutableUsingReflection() throws NoSuchFieldException, IllegalAccessException {
+        String myString = "Hello World";
+        String otherString = new String("Hello World");
+        Field f = String.class.getDeclaredField("value");
+        f.setAccessible(true);
+        f.set(myString, "Hi World".toCharArray());
+        System.out.println(otherString);
+    }
+}

core-java-modules/core-java-string-operations-7/src/main/java/com/baeldung/unicode/UnicodeLetterChecker.java

@@ -0,0 +1,30 @@
+package com.baeldung.unicode;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.apache.commons.lang3.StringUtils;
+
+public class UnicodeLetterChecker {
+    public boolean characterClassCheck(String input) {
+        for (char c : input.toCharArray()) {
+            if (!Character.isLetter(c)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    public boolean regexCheck(String input) {
+        Pattern pattern = Pattern.compile("^\\p{L}+$");
+        Matcher matcher = pattern.matcher(input);
+        return matcher.matches();
+    }
+    
+    public boolean isAlphaCheck(String input) {
+        return StringUtils.isAlpha(input);
+    }
+    
+    public boolean StreamsCheck(String input) {
+        return input.codePoints().allMatch(Character::isLetter);
+    }
+}

core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/mutablestring/CharsetUsageUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.mutablestring;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.mutablestrings.CharsetUsageExample;
+
+public class CharsetUsageUnitTest {
+
+    @Test
+    public void givenCharset_whenStringIsEncodedAndDecoded_thenGivesCorrectResult() {
+        CharsetUsageExample ch = new CharsetUsageExample();
+        String inputString = "hello दुनिया";
+        String result = ch.decodeString(ch.encodeString(inputString));
+        Assertions.assertEquals(inputString, result);
+    }
+}

core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/mutablestring/MutableStringUsingCharsetUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.mutablestring;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.mutablestrings.MutableStringUsingCharset;
+
+public class MutableStringUsingCharsetUnitTest {
+    @Test
+    @Disabled
+    /**
+     * This test is disabled as it works well for Java 8 and below
+     */
+    public void givenCustomCharSet_whenStringUpdated_StringGetsMutated() throws Exception {
+        MutableStringUsingCharset ms = new MutableStringUsingCharset();
+        String s = ms.createModifiableString("Hello");
+        Assert.assertEquals("Hello", s);
+        ms.modifyString();
+        Assert.assertEquals("something", s);
+    }
+
+}
+

core-java-modules/core-java-string-operations-7/src/test/java/com/baeldung/unicode/UnicodeLetterCheckerUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.unicode;
+
+import org.junit.Test;
+import static org.junit.Assert.assertTrue;
+
+public class UnicodeLetterCheckerUnitTest {
+    @Test
+    public void givenString_whenUsingIsLetter_thenReturnTrue() {
+        UnicodeLetterChecker checker = new UnicodeLetterChecker();
+
+        boolean isUnicodeLetter = checker.characterClassCheck("HelloWorld");
+        assertTrue(isUnicodeLetter);
+    }
+
+    @Test
+    public void givenString_whenUsingRegex_thenReturnTrue() {
+        UnicodeLetterChecker checker = new UnicodeLetterChecker();
+
+        boolean isUnicodeLetter = checker.regexCheck("HelloWorld");
+        assertTrue(isUnicodeLetter);
+    }
+
+    @Test
+    public void givenString_whenUsingIsAlpha_thenReturnTrue() {
+        UnicodeLetterChecker checker = new UnicodeLetterChecker();
+
+        boolean isUnicodeLetter = checker.isAlphaCheck("HelloWorld");
+        assertTrue(isUnicodeLetter);
+    }
+
+    @Test
+    public void givenString_whenUsingStreams_thenReturnTrue() {
+        UnicodeLetterChecker checker = new UnicodeLetterChecker();
+
+        boolean isUnicodeLetter = checker.StreamsCheck("HelloWorld");
+        assertTrue(isUnicodeLetter);
+    }
+}

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

@@ -14,3 +14,5 @@ Listed here there are only those articles that does not fit into other core-java
 - [Java String Interview Questions and Answers](https://www.baeldung.com/java-string-interview-questions)
 - [Java Multi-line String](https://www.baeldung.com/java-multiline-string)
 - [Reuse StringBuilder for Efficiency](https://www.baeldung.com/java-reuse-stringbuilder-for-efficiency)
+- [How to Iterate Over the String Characters in Java](https://www.baeldung.com/java-iterate-string-characters)
+- [Passing Strings by Reference in Java](https://www.baeldung.com/java-method-pass-string-reference)

core-java-modules/core-java-strings/src/main/java/com/baeldung/stringIterator/StringIterator.java

@@ -0,0 +1,42 @@
+package com.baeldung.stringIterator;
+
+import java.text.*; 
+import java.util.*;
+
+public class StringIterator {
+
+    public static String javaCharArray(String str){
+        StringBuilder result = new StringBuilder();
+        for (char c : str.toCharArray()) { 
+            result.append(c);
+        }
+        return result.toString();
+    }
+
+    public static String javaforLoop(String str) {
+        StringBuilder result = new StringBuilder();
+        for (int i = 0; i < str.length(); i++) {
+            char c = str.charAt(i);
+            result.append(c);
+        }
+        return result.toString();
+    }
+
+    public static String java8forEach(String str){
+        StringBuilder result = new StringBuilder();
+        str.chars().forEach(name -> {
+            result.append((char) name);
+        });
+        return result.toString();
+    }
+
+    public static String javaCharacterIterator(String str){
+        StringBuilder result = new StringBuilder();
+        CharacterIterator it = new StringCharacterIterator(str);  
+        while (it.current() != CharacterIterator.DONE) { 
+            result.append(it.current()); 
+            it.next(); 
+        }
+        return result.toString();
+    }
+}

core-java-modules/core-java-strings/src/test/java/com/baeldung/stringIterator/StringIteratorTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.stringIterator;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class StringIteratorTest {
+  
+    @Test
+    public void whenUseCharArrayMethod_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaCharArray(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseJavaForLoop_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaForLoop(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseForEachMethod_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.java8ForEach(input);
+        assertEquals(expectedOutput, result);
+    }
+  
+    @Test
+    public void whenUseCharacterIterator_thenIterate() {
+        String input = "Hello, Baeldung!";
+        String expectedOutput = "Hello, Baeldung!";
+        String result = StringIterator.javaCharacterIterator(input);
+        assertEquals(expectedOutput, result);
+    }
+}

core-java-modules/java-native/pom.xml

@@ -7,9 +7,9 @@
     <name>java-native</name>
 
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-modules</artifactId>
-        <version>1.0.0-SNAPSHOT</version>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
     </parent>
 
     <dependencies>

core-java-modules/pom.xml

@@ -199,6 +199,7 @@
         <module>core-java-date-operations-1</module>
         <!--<module>core-java-datetime-conversion</module>--> <!--JAVA-25433-->
         <module>core-java-httpclient</module>
+        <module>java-native</module>
     </modules>
 
     <dependencyManagement>

data-structures/src/main/java/com/baeldung/avltree/AVLTree.java

@@ -42,17 +42,17 @@ public class AVLTree {
         return root == null ? -1 : root.height;
     }
 
-    private Node insert(Node node, int key) {
-        if (node == null) {
+    private Node insert(Node root, int key) {
+        if (root == null) {
             return new Node(key);
-        } else if (node.key > key) {
-            node.left = insert(node.left, key);
-        } else if (node.key < key) {
-            node.right = insert(node.right, key);
+        } else if (root.key > key) {
+            root.left = insert(root.left, key);
+        } else if (root.key < key) {
+            root.right = insert(root.right, key);
         } else {
             throw new RuntimeException("duplicate Key!");
         }
-        return rebalance(node);
+        return rebalance(root);
     }
 
     private Node delete(Node node, int key) {

gradle-modules/gradle-7/README.md

@@ -5,5 +5,4 @@
 - [Working With Multiple Repositories in Gradle](https://www.baeldung.com/java-gradle-multiple-repositories)
 - [Different Dependency Version Declarations in Gradle](https://www.baeldung.com/gradle-different-dependency-version-declarations)
 - [Generating Javadoc With Gradle](https://www.baeldung.com/java-gradle-javadoc)
-- [Generating WSDL Stubs With Gradle](https://www.baeldung.com/java-gradle-create-wsdl-stubs)
-- [Gradle Toolchains Support for JVM Projects](https://www.baeldung.com/java-gradle-toolchains-jvm-projects)
+- [Generating WSDL Stubs With Gradle](https://www.baeldung.com/java-gradle-create-wsdl-stubs)

gradle-modules/gradle-7/conditional-dependency-demo/.gitignore

@@ -1,7 +1,7 @@
 HELP.md
 .gradle
 build/
-!gradle/wrapper/gradle-wrapper.jar
+!../gradle/wrapper/gradle-wrapper.jar
 !**/src/main/**/build/
 !**/src/test/**/build/
 

gradle-modules/gradle-7/conditional-dependency-demo/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

gradle-modules/gradle-7/conditional-dependency-demo/gradlew

@@ -1,234 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
-APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

gradle-modules/gradle-7/conditional-dependency-demo/gradlew.bat

@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

gradle-modules/gradle-7/gradle-javadoc/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.5.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

gradle-modules/gradle-7/gradle-javadoc/gradlew

@@ -1,240 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
-APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

gradle-modules/gradle-7/gradle-javadoc/gradlew.bat

@@ -1,91 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%"=="" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

gradle-modules/gradle-7/gradle-wsdl-stubs/build.gradle

@@ -1,6 +1,6 @@
 plugins {
     id 'java'
-    id("com.github.bjornvester.wsdl2java") version "1.2"
+    id 'com.github.bjornvester.wsdl2java' version '2.0.2'
 }
 
 repositories {
@@ -17,7 +17,6 @@ test {
     useJUnitPlatform()
 }
 
-
 wsdl2java {
-    cxfVersion.set("3.4.4")
+    cxfVersion.set("4.0.2")
 }

gradle-modules/gradle-7/gradle-wsdl-stubs/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
-networkTimeout=10000
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

gradle-modules/gradle-7/gradle-wsdl-stubs/gradlew

@@ -1,244 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

gradle-modules/gradle-7/gradle-wsdl-stubs/gradlew.bat

@@ -1,92 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%"=="" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

gradle-modules/gradle-7/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.3-bin.zip
 networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradle-modules/gradle-7/gradlew

@@ -83,7 +83,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -130,10 +131,13 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
@@ -141,7 +145,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -149,7 +153,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -198,11 +202,11 @@ fi
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \

gradle-modules/gradle-7/multiple-repositories-demo/multiple-repositories/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists