Merge branch 'eugenp:master' into master

Author: degr8sid-code

.gitignore

@@ -61,9 +61,9 @@ dependency-reduced-pom.xml
 *.dylib
 *.dll
 
-xml/src/test/resources/example_dom4j_new.xml
-xml/src/test/resources/example_dom4j_updated.xml
-xml/src/test/resources/example_jaxb_new.xml
+xml-modules/xml/src/test/resources/example_dom4j_new.xml
+xml-modules/xml/src/test/resources/example_dom4j_updated.xml
+xml-modules/xml/src/test/resources/example_jaxb_new.xml
 core-java-io/hard_link.txt
 core-java-io/target_link.txt
 core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
@@ -99,7 +99,7 @@ customers.xml
 apache-cxf/cxf-aegis/baeldung.xml
 testing-modules/report-*.json
 
-libraries-2/*.db
+libraries-4/*.db
 
 apache-spark/data/output
 logs/
@@ -140,6 +140,7 @@ persistence-modules/neo4j/data/**
 /microservices-modules/micronaut-reactive/.micronaut/test-resources/test-resources.properties
 /libraries-security/src/main/resources/home/upload/test_file_SCP.txt
 /libraries-security/src/main/resources/home/upload/test_file_SFTP.txt
+/libraries-security/decryptedFile
 /libraries-data-io/src/test/resources/protocols/gson_user.json
 /libraries-io/src/main/resources/application.csv
 /libraries-io/src/main/resources/application2.csv
@@ -149,7 +150,7 @@ persistence-modules/neo4j/data/**
 /core-java-modules/core-java-io-conversions-3/src/test/resources/xlsxToCsv_output.csv
 /core-java-modules/core-java-io-5/output.txt
 /core-java-modules/core-java-io-apis-2/sample.txt
-/persistence-modules/core-java-persistence-3/test.mv.db
+/persistence-modules/core-java-persistence/test.mv.db
 /apache-libraries/src/main/java/com/baeldung/apache/avro/
 /apache-libraries-2/cars.avro
 
@@ -160,4 +161,9 @@ persistence-modules/neo4j/data/**
 /spring-cloud-modules/spring-cloud-bootstrap/gateway/src/main/resources/static/home/server/*
 
 /web-modules/linkrest/src/main/java/com/baeldung/cayenne/auto/_Department.java
-/web-modules/linkrest/src/main/java/com/baeldung/cayenne/auto/_Employee.java
+/web-modules/linkrest/src/main/java/com/baeldung/cayenne/auto/_Employee.java
+
+#log4j
+logging-modules/log4j/app-dynamic-log.log
+logging-modules/logback/conditional.log
+logging-modules/logback/filtered.log

README.md

@@ -36,13 +36,13 @@ Profile-based segregation
 
 We use Maven build profiles to segregate the huge list of individual projects in our repository.
 
-The projects are broadly divided into 6 lists: default, default-jdk17, default-jdk22, default-jdk23, default-jdk8 and default-heavy. 
+The projects are broadly divided into 8 lists: default, default-jdk17, default-jdk22, default-jdk23, default-jdk24, default-jdk25, default-jdk8 and default-heavy. 
 
 Next, they are segregated further based on the tests that we want to execute.
 
 We also have a parents profile to build only parent modules.
 
-Therefore, we have a total of 13 profiles:
+Therefore, we have a total of 17 profiles:
 
 | Profile           | Includes                    | Type of test enabled |
 |-------------------|-----------------------------|----------------------|
@@ -54,6 +54,10 @@ Therefore, we have a total of 13 profiles:
 | integration-jdk22 | JDK22 projects              | *IntegrationTest     |
 | default-jdk23     | JDK23 projects              | *UnitTest            |
 | integration-jdk23 | JDK23 projects              | *IntegrationTest     |
+| default-jdk24     | JDK24 projects              | *UnitTest            |
+| integration-jdk24 | JDK24 projects              | *IntegrationTest     |
+| default-jdk25     | JDK25 projects              | *UnitTest            |
+| integration-jdk25 | JDK25 projects              | *IntegrationTest     |
 | default-heavy     | Heavy/long running projects | *UnitTest            |
 | integration-heavy | Heavy/long running projects | *IntegrationTest     |
 | default-jdk8      | JDK8  projects              | *UnitTest            |

algorithms-modules/algorithms-numeric/src/main/java/com/baeldung/algorithms/bcdtodecimal/BCDtoDecimalConverter.java

@@ -0,0 +1,48 @@
+package com.baeldung.algorithms.bcdtodecimal;
+
+public class BCDtoDecimalConverter {
+    /**
+     * Converts a single packed BCD byte to an integer.
+     * Each byte represents two decimal digits.
+     *
+     * @param bcdByte The BCD byte to convert.
+     * @return The decimal integer value.
+     * @throws IllegalArgumentException if any nibble contains a non-BCD value (>9).
+     */
+    public static int convertPackedByte(byte bcdByte) {
+        int resultDecimal;
+        int upperNibble = (bcdByte >> 4) & 0x0F;
+        int lowerNibble = bcdByte & 0x0F;
+        if (upperNibble > 9 || lowerNibble > 9) {
+            throw new IllegalArgumentException(
+                String.format("Invalid BCD format: byte 0x%02X contains non-decimal digit.", bcdByte)
+            );
+        }
+        resultDecimal = upperNibble * 10 + lowerNibble;
+        return resultDecimal;
+    }
+
+    /**
+     * Converts a BCD byte array to a long decimal value.
+     * Each byte in the array iis mapped to a packed BCD byte,
+     * representing two BCD nibbles.
+     *
+     * @param bcdArray The array of BCD bytes.
+     * @return The combined long decimal value.
+     * @throws IllegalArgumentException if any nibble contains a non-BCD value (>9).
+     */
+    public static long convertPackedByteArray(byte[] bcdArray) {
+        long resultDecimal = 0;
+        for (byte bcd : bcdArray) {
+            int upperNibble = (bcd >> 4) & 0x0F;
+            int lowerNibble = bcd & 0x0F;
+
+            if (upperNibble > 9 || lowerNibble > 9) {
+                throw new IllegalArgumentException("Invalid BCD format: nibble contains non-decimal digit.");
+            }
+
+            resultDecimal = resultDecimal * 100 + (upperNibble * 10 + lowerNibble);
+        }
+        return resultDecimal;
+    }
+}

algorithms-modules/algorithms-numeric/src/main/java/com/baeldung/algorithms/sumoftwosquares/NumberAsSumOfTwoSquares.java

@@ -0,0 +1,59 @@
+package com.baeldung.algorithms.sumoftwosquares;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class NumberAsSumOfTwoSquares {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(NumberAsSumOfTwoSquares.class);
+
+    /**
+     * Checks if a non-negative integer n can be written as the
+     * sum of two squares i.e. (a^2 + b^2)
+     * This implementation is based on Fermat's theorem on sums of two squares.
+     *
+     * @param n The number to check (must be non-negative).
+     * @return true if n can be written as a sum of two squares, false otherwise.
+     */
+    public static boolean isSumOfTwoSquares(int n) {
+        if (n < 0) {
+            LOGGER.warn("Input must be non-negative. Returning false for n = {}", n);
+            return false;
+        }
+        if (n == 0) {
+            return true; // 0 = 0^2 + 0^2
+        }
+
+        // 1. Reduce n to an odd number if n is even.
+        while (n % 2 == 0) {
+            n /= 2;
+        }
+
+        // 2. Iterate through odd prime factors starting from 3
+        for (int i = 3; i * i <= n; i += 2) {
+            // 2a. Find the exponent of the factor i
+            int count = 0;
+            while (n % i == 0) {
+                count++;
+                n /= i;
+            }
+
+            // 2b. Check the condition from Fermat's theorem
+            // If i is of form 4k+3 (i % 4 == 3) and has an odd exponent
+            if (i % 4 == 3 && count % 2 != 0) {
+                LOGGER.debug("Failing condition: factor {} (form 4k+3) has odd exponent {}", i, count);
+                return false;
+            }
+        }
+
+        // 3. Handle the last remaining factor (which is prime if > 1)
+        // If n itself is a prime of the form 4k+3, its exponent is 1 (odd).
+        if (n % 4 == 3) {
+            LOGGER.debug("Failing condition: remaining factor {} is of form 4k+3", n);
+            return false;
+        }
+
+        // 4. All 4k+3 primes had even exponents.
+        return true;
+    }
+}

algorithms-modules/algorithms-numeric/src/main/java/com/baeldung/algorithms/twoanglesdifference/AngleDifferenceCalculator.java

@@ -0,0 +1,64 @@
+/**
+ * Package to host code for calculating three types of angle difference
+ */
+package com.baeldung.algorithms.twoanglesdifference;
+
+public class AngleDifferenceCalculator {
+
+    /**
+     * Normalizes an angle to be within the range [0, 360).
+     *
+     * @param angle The angle in degrees.
+     * @return The normalized angle.
+     */
+    public static double normalizeAngle(double angle) {
+        return (angle % 360 + 360) % 360;
+    }
+
+    /**
+     * Calculates the absolute difference between two angles.
+     *
+     * @param angle1 The first angle in degrees.
+     * @param angle2 The second angle in degrees.
+     * @return The absolute difference in degrees.
+     */
+    public static double absoluteDifference(double angle1, double angle2) {
+        return Math.abs(angle1 - angle2);
+    }
+
+    /**
+     * Calculates the shortest difference between two angles.
+     *
+     * @param angle1 The first angle in degrees.
+     * @param angle2 The second angle in degrees.
+     * @return The shortest difference in degrees (0 to 180).
+     */
+    public static double shortestDifference(double angle1, double angle2) {
+        double diff = absoluteDifference(normalizeAngle(angle1), normalizeAngle(angle2));
+        return Math.min(diff, 360 - diff);
+    }
+
+    /**
+     * Calculates the signed shortest difference between two angles.
+     * A positive result indicates counter-clockwise rotation, a negative result indicates clockwise.
+     *
+     * @param angle1 The first angle in degrees.
+     * @param angle2 The second angle in degrees.
+     * @return The signed shortest difference in degrees (-180 to 180).
+     */
+    public static double signedShortestDifference(double angle1, double angle2) {
+        double normalizedAngle1 = normalizeAngle(angle1);
+        double normalizedAngle2 = normalizeAngle(angle2);
+        double diff = normalizedAngle2 - normalizedAngle1;
+
+        if (diff > 180) {
+            return diff - 360;
+        } else if (diff < -180) {
+            return diff + 360;
+        } else {
+            return diff;
+        }
+    }
+}
+
+

algorithms-modules/algorithms-numeric/src/test/java/com/baeldung/algorithms/bcdtodecimal/BCDtoDecimalConverterTest.java

@@ -0,0 +1,95 @@
+package com.baeldung.algorithms.bcdtodecimal;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class BCDtoDecimalConverterTest {
+
+    // 1. Tests for convertPackedByte(byte bcdByte)
+
+    @Test
+    void testConvertPackedByteValidValues() {
+        // Test 05 (0x05) ->
+        assertEquals(5, BCDtoDecimalConverter.convertPackedByte((byte) 0x05));
+
+        // Test 22 (0x22) -> 22
+        assertEquals(22, BCDtoDecimalConverter.convertPackedByte((byte) 0x22));
+
+        // Test 97 (0x97) -> 97
+        assertEquals(97, BCDtoDecimalConverter.convertPackedByte((byte) 0x097));
+    }
+
+    @Test
+    void testConvertPackedByteInvalidUpperNibbleThrowsException() {
+        // Test Upper nibble is A (1010), Lower nibble is 1 (0001) -> 0xA1
+        byte invalidByte = (byte) 0xA1;
+        assertThrows(IllegalArgumentException.class, () -> BCDtoDecimalConverter.convertPackedByte(invalidByte),
+            "Received non-BCD upper nibble (A). Provide valid BCD nibbles (0-9).");
+    }
+
+    @Test
+    void testConvertPackedByteBothInvalidThrowsException() {
+        // test Upper nibble is B, Lower nibble is E -> 0xBE
+        byte invalidByte = (byte) 0xBE;
+        assertThrows(IllegalArgumentException.class,
+            () -> BCDtoDecimalConverter.convertPackedByte(invalidByte),
+            "Received both nibbles as non-BCD. Provide valid BCD nibbles (0-9)."
+        );
+    }
+
+    // -------------------------------------------------------------------------
+
+    // 2. Tests for convertPackedByteArray(byte[] bcdArray)
+
+    @Test
+    void testConvertPackedByteArrayValidValues() {
+        // Test 0 -> [0x00]
+        assertEquals(0L, BCDtoDecimalConverter.convertPackedByteArray(new byte[]{(byte) 0x00}));
+
+        // Test 99 -> [0x99]
+        assertEquals(99L, BCDtoDecimalConverter.convertPackedByteArray(new byte[]{(byte) 0x99}));
+
+        // Test 1234 -> [0x12, 0x34]
+        byte[] bcd1234 = {(byte) 0x12, (byte) 0x34};
+        assertEquals(1234L, BCDtoDecimalConverter.convertPackedByteArray(bcd1234));
+
+        // Test 12345678 -> [0x12, 0x34, 0x56, 0x78]
+        byte[] bcdLarge = {(byte) 0x12, (byte) 0x34, (byte) 0x56, (byte) 0x78};
+        assertEquals(12345678L, BCDtoDecimalConverter.convertPackedByteArray(bcdLarge));
+    }
+
+    @Test
+    void testConvertPackedByteArrayEmptyArray() {
+        // Test empty array -> 0
+        assertEquals(0L, BCDtoDecimalConverter.convertPackedByteArray(new byte[]{}));
+    }
+
+    @Test
+    void testConvertPackedByteArrayMaximumSafeLong() {
+        // Test a large number that fits within a long (18 digits)
+        // 999,999,999,999,999,999 (18 nines)
+        byte[] bcdMax = {(byte) 0x99, (byte) 0x99, (byte) 0x99, (byte) 0x99, (byte) 0x99, (byte) 0x99, (byte) 0x99, (byte) 0x99, (byte) 0x99};
+        assertEquals(999999999999999999L, BCDtoDecimalConverter.convertPackedByteArray(bcdMax));
+    }
+
+    @Test
+    void testConvertPackedByteArrayInvalidNibbleThrowsException() {
+        // Contains 0x1A (A is an invalid BCD digit)
+        byte[] bcdInvalid = {(byte) 0x12, (byte) 0x1A, (byte) 0x34};
+        assertThrows(IllegalArgumentException.class,
+            () -> BCDtoDecimalConverter.convertPackedByteArray(bcdInvalid),
+            "Received array containing an invalid BCD byte. Provide valid BCD nibbles (0-9)."
+        );
+    }
+
+    @Test
+    void testConvertPackedByteArray_InvalidFirstByteThrowsException() {
+        // Invalid BCD byte at the start
+        byte[] bcdInvalid = {(byte) 0xF0, (byte) 0x12};
+        assertThrows(IllegalArgumentException.class,
+            () -> BCDtoDecimalConverter.convertPackedByteArray(bcdInvalid),
+            "Received first byte as an invalid BCD byte. Provide valid BCD nibbles (0-9)."
+        );
+    }
+}

algorithms-modules/algorithms-numeric/src/test/java/com/baeldung/algorithms/sumoftwosquares/NumberAsSumOfTwoSquaresUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.algorithms.sumoftwosquares;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.DisplayName;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+
+class NumberAsSumOfTwoSquaresUnitTest {
+
+    @Test
+    @DisplayName("Given input number can be expressed as a sum of squares, when checked, then returns true")
+    void givenNumberIsSumOfSquares_whenCheckIsCalled_thenReturnsTrue() {
+        // Simple cases
+        assertTrue(NumberAsSumOfTwoSquares.isSumOfTwoSquares(0)); // 0^2 + 0^2
+        assertTrue(NumberAsSumOfTwoSquares.isSumOfTwoSquares(1)); // 1^2 + 0^2
+        assertTrue(NumberAsSumOfTwoSquares.isSumOfTwoSquares(5)); // 1^2 + 2^2
+        assertTrue(NumberAsSumOfTwoSquares.isSumOfTwoSquares(8)); // 2^2 + 2^2
+
+        // Cases from Fermat theorem
+        assertTrue(NumberAsSumOfTwoSquares.isSumOfTwoSquares(50)); // 2 * 5^2. No 4k+3 primes.
+        assertTrue(NumberAsSumOfTwoSquares.isSumOfTwoSquares(45)); // 3^2 * 5. 4k+3 prime (3) has even exp.
+        assertTrue(NumberAsSumOfTwoSquares.isSumOfTwoSquares(18)); // 2 * 3^2. 4k+3 prime (3) has even exp.
+    }
+
+    @Test
+    @DisplayName("Given input number can't be expressed as a sum of squares, when checked, then returns false")
+    void givenNumberIsNotSumOfSquares_whenCheckIsCalled_thenReturnsFalse() {
+        // Simple cases
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(3));  // 3 (4k+3, exp 1)
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(6));  // 2 * 3 (3 has exp 1)
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(7));  // 7 (4k+3, exp 1)
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(11)); // 11 (4k+3, exp 1)
+
+        // Cases from theorem
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(12)); // 2^2 * 3 (3 has exp 1)
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(21)); // 3 * 7 (both 3 and 7 have exp 1)
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(28)); // 2^2 * 7 (7 has exp 1)
+    }
+
+    @Test
+    @DisplayName("Given input number is negative, when checked, then returns false")
+    void givenNegativeNumber_whenCheckIsCalled_thenReturnsFalse() {
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(-1)); // Negatives as hygiene
+        assertFalse(NumberAsSumOfTwoSquares.isSumOfTwoSquares(-10)); // Negatives as hygiene
+    }
+}