Merge branch 'eugenp:master' into danielmcnally285_return_first_non_null

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-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-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-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-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 static org.junit.jupiter.api.Assertions.assertEquals;
-import org.junit.Test;
+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;
+    @BeforeAll
-
+    public static void init() {
-    @Before
-    public 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() {
+    void checkStreamCount_whenOperationFilter_thanCorrect() {
-        Stream<String> streamFilter = list.stream().filter(element -> element.isEmpty());
+        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() {
+    void checkStreamCount_whenOperationMatch_thenCorrect() {
-        boolean isValid = list.stream().anyMatch(element -> element.contains("h"));
+        boolean isValid = list.stream()
-        boolean isValidOne = list.stream().allMatch(element -> element.contains("h"));
+            .anyMatch(element -> element.contains("h"));
-        boolean isValidTwo = list.stream().noneMatch(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() {
+    void checkStreamContains_whenOperationCollect_thenCorrect() {
-        List<String> resultList = list.stream().map(element -> element.toUpperCase()).collect(Collectors.toList());
+        List<String> resultList = list.stream()
+            .map(element -> element.toUpperCase())
+            .collect(Collectors.toList());
         assertEquals(resultList.size(), list.size());
         assertTrue(resultList.contains(""));
     }
 
     @Test
     public void checkParallelStream_whenDoWork() {
-        list.parallelStream().forEach(element -> doWork(element));
+        list.parallelStream()
+            .forEach(element -> doWork(element));
     }
 
     private void doWork(String string) {

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/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-strings/README.md

@@ -14,3 +14,4 @@ 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)

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>
+        <groupId>com.baeldung.core-java-modules</groupId>
-        <artifactId>parent-modules</artifactId>
+        <artifactId>core-java-modules</artifactId>
-        <version>1.0.0-SNAPSHOT</version>
+        <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>

gradle-modules/gradle-7/README.md

@@ -6,4 +6,3 @@
 - [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)

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.1.1-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,18 +131,21 @@ 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.
 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;
+# Collect all arguments for the java command:
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     shell script including quotes and variable substitutions, so put them in
+#     and any embedded shellness will be escaped.
-#     double quotes to make sure that they get re-expanded; and
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#   * put everything else in single quotes, so that it's not re-expanded.
+#     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

gradle-modules/gradle-7/multiple-repositories-demo/multiple-repositories/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/multiple-repositories-demo/multiple-repositories/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/multiple-repositories-demo/publish-package/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

gradle-modules/gradle-7/multiple-repositories-demo/publish-package/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/multiple-repositories-demo/publish-package/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/multiple-repositories-demo/settings.gradle

@@ -0,0 +1,4 @@
+rootProject.name = 'multiple-repositories-demo'
+
+include 'multiple-repositories'
+include 'publish-package'

gradle-modules/gradle-7/settings.gradle

@@ -0,0 +1,7 @@
+rootProject.name = 'gradle-7'
+
+include 'conditional-dependency-demo'
+include 'dependency-version'
+include 'gradle-javadoc'
+include 'gradle-wsdl-stubs'
+include 'multiple-repositories-demo'

gradle-modules/gradle-8/README.md

@@ -0,0 +1,4 @@
+
+### Relevant Articles:
+
+- [Gradle Toolchains Support for JVM Projects](https://www.baeldung.com/java-gradle-toolchains-jvm-projects)

gradle-modules/gradle-8/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-8.4-bin.zip
 networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradle-modules/gradle-8/gradlew

@@ -83,10 +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
-# 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
@@ -133,18 +131,21 @@ 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.
 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
@@ -152,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
@@ -197,11 +198,15 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
+
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-#     shell script including quotes and variable substitutions, so put them in
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-#     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-8/settings.gradle

@@ -0,0 +1,3 @@
+rootProject.name = 'gradle-8'
+
+include 'toolchains-feature'

gradle-modules/settings.gradle

@@ -3,3 +3,5 @@ include 'gradle'
 include 'gradle-5'
 include 'gradle-6'
 include 'gradle-7'
+include 'gradle-8'
+include 'gradle-customization'