Merge branch 'eugenp:master' into master

Author: wynnteo

apache-poi-4/.gitignore

@@ -0,0 +1 @@
+CellStyleTest_output.xlsx

apache-poi-4/CellStyleTest_output.xlsx

@@ -0,0 +1,89 @@
+package com.baeldung.spark.dataframeconcat;
+
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.SparkSession;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class ConcatRowsExample {
+
+    private static final Logger logger = LoggerFactory.getLogger(ConcatRowsExample.class);
+
+    public static void main(String[] args) {
+        SparkSession spark = SparkSession.builder()
+          .appName("Row-wise Concatenation Example")
+          .master("local[*]")
+          .getOrCreate();
+
+        try {
+            // Create sample data
+            List<Person> data1 = Arrays.asList(
+                new Person(1, "Alice"),
+                new Person(2, "Bob")
+            );
+
+            List<Person> data2 = Arrays.asList(
+                new Person(3, "Charlie"),
+                new Person(4, "Diana")
+            );
+
+            Dataset<Row> df1 = spark.createDataFrame(data1, Person.class);
+            Dataset<Row> df2 = spark.createDataFrame(data2, Person.class);
+
+            logger.info("First DataFrame:");
+            df1.show();
+
+            logger.info("Second DataFrame:");
+            df2.show();
+
+            // Row-wise concatenation using reusable method
+            Dataset<Row> combined = concatenateDataFrames(df1, df2);
+
+            logger.info("After row-wise concatenation:");
+            combined.show();
+        } finally {
+            spark.stop();
+        }
+    }
+
+    /**
+     * Concatenates two DataFrames row-wise using unionByName.
+     * This method is extracted for reusability and testing.
+     */
+    public static Dataset<Row> concatenateDataFrames(Dataset<Row> df1, Dataset<Row> df2) {
+        return df1.unionByName(df2);
+    }
+
+    public static class Person implements java.io.Serializable {
+        private int id;
+        private String name;
+
+        public Person() {
+        }
+
+        public Person(int id, String name) {
+            this.id = id;
+            this.name = name;
+        }
+
+        public int getId() {
+            return id;
+        }
+
+        public void setId(int id) {
+            this.id = id;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+    }
+}

apache-spark/src/main/java/com/baeldung/spark/dataframeconcat/ConcatRowsExample.java

@@ -0,0 +1,83 @@
+package com.baeldung.spark.dataframeconcat;
+
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.SparkSession;
+import org.junit.jupiter.api.*;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ConcatRowsExampleUnitTest {
+
+    private static SparkSession spark;
+    private Dataset<Row> df1;
+    private Dataset<Row> df2;
+
+    @BeforeAll
+    static void setupClass() {
+        spark = SparkSession.builder()
+          .appName("Row-wise Concatenation Test")
+          .master("local[*]")
+          .getOrCreate();
+    }
+
+    @BeforeEach
+    void setup() {
+        df1 = spark.createDataFrame(
+            Arrays.asList(
+                new ConcatRowsExample.Person(1, "Alice"),
+                new ConcatRowsExample.Person(2, "Bob")
+            ),
+            ConcatRowsExample.Person.class
+        );
+
+        df2 = spark.createDataFrame(
+            Arrays.asList(
+                new ConcatRowsExample.Person(3, "Charlie"),
+                new ConcatRowsExample.Person(4, "Diana")
+            ),
+            ConcatRowsExample.Person.class
+        );
+    }
+
+    @AfterAll
+    static void tearDownClass() {
+        spark.stop();
+    }
+
+    @Test
+    void givenTwoDataFrames_whenConcatenated_thenRowCountMatches() {
+        Dataset<Row> combined = ConcatRowsExample.concatenateDataFrames(df1, df2);
+
+        assertEquals(
+            4,
+            combined.count(),
+            "The combined DataFrame should have 4 rows"
+        );
+    }
+
+    @Test
+    void givenTwoDataFrames_whenConcatenated_thenSchemaRemainsSame() {
+        Dataset<Row> combined = ConcatRowsExample.concatenateDataFrames(df1, df2);
+
+        assertEquals(
+            df1.schema(),
+            combined.schema(),
+            "Schema should remain consistent after concatenation"
+        );
+    }
+
+    @Test
+    void givenTwoDataFrames_whenConcatenated_thenDataContainsExpectedName() {
+        Dataset<Row> combined = ConcatRowsExample.concatenateDataFrames(df1, df2);
+
+        assertTrue(
+          combined
+            .filter("name = 'Charlie'")
+            .count() > 0,
+          "Combined DataFrame should contain Charlie"
+        );
+    }
+}

apache-spark/src/test/java/com/baeldung/spark/dataframeconcat/ConcatRowsExampleUnitTest.java

@@ -0,0 +1,33 @@
+package com.baeldung.objectarray;
+
+public class ObjectArray {
+
+    public static Object[] createSampleArray() {
+        Object[] values = new Object[5];
+        values[0] = "Hello";                  // String
+        values[1] = 42;                       // Autoboxed Integer
+        values[2] = 3.14;                     // Autoboxed Double
+        values[3] = new int[]{1, 2, 3};      // int[] array
+        values[4] = new Person("Alice", 30); // Custom class
+        return values;
+    }
+
+    // Nested static Person class
+    public static class Person {
+        private final String name;
+        private final int age;
+
+        public Person(String name, int age) {
+            this.name = name;
+            this.age = age;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public int getAge() {
+            return age;
+        }
+    }
+}

core-java-modules/core-java-arrays-guides/src/main/java/com/baeldung/objectarray/ObjectArray.java

@@ -0,0 +1,37 @@
+package com.baeldung.objectarray;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ObjectArrayUnitTest {
+
+    @Test
+    void givenObjectArray_whenHoldingDifferentTypes_thenCorrect() {
+        Object[] values = ObjectArray.createSampleArray();
+
+        assertEquals("Hello", values[0]);                   // String stored
+        assertEquals(42, values[1]);                        // Integer stored
+        assertEquals(3.14, values[2]);                      // Double stored
+        assertTrue(values[3] instanceof int[]);             // Array stored
+        assertTrue(values[4] instanceof ObjectArray.Person);// Custom class stored
+    }
+
+    @Test
+    void givenObjectArray_whenAccessingPerson_thenCorrect() {
+        Object[] values = ObjectArray.createSampleArray();
+
+        ObjectArray.Person person = (ObjectArray.Person) values[4];
+        assertEquals("Alice", person.getName());           // Name matches
+        assertEquals(30, person.getAge());                 // Age matches
+    }
+
+    @Test
+    void givenObjectArray_whenCastingIncorrectly_thenClassCastException() {
+        Object[] values = ObjectArray.createSampleArray();
+
+        assertThrows(ClassCastException.class, () -> {
+            String wrongCast = (String) values[1];         // values[1] is actually Integer
+        });
+    }
+}

core-java-modules/core-java-arrays-guides/src/test/java/com/baeldung/objectarray/ObjectArrayUnitTest.java

@@ -13,7 +13,7 @@ public class FormatDurationUnitTest {
 
 
     @Test
-    public void givenInterval_WhenFormatInterval_formatDuration() {
+    public void givenInterval_whenFormatInterval_thenFormatDuration() {
         long HH = TimeUnit.MILLISECONDS.toHours(38114000);
         long MM = TimeUnit.MILLISECONDS.toMinutes(38114000) % 60;
         long SS = TimeUnit.MILLISECONDS.toSeconds(38114000) % 60;
@@ -23,7 +23,16 @@ public void givenInterval_WhenFormatInterval_formatDuration() {
     }
 
     @Test
-    public void givenInterval_WhenFormatUsingDuration_formatDuration() {
+    public void givenIntMinutes_whenConvertUsingTimeUnit_thenFormatHHMM() {
+        int totalMinutes = 155;  
+        long hours = TimeUnit.MINUTES.toHours(totalMinutes); 
+        long remainingMinutes = totalMinutes - TimeUnit.HOURS.toMinutes(hours);
+        String timeInHHMM = String.format("%02d:%02d", hours, remainingMinutes);
+        assertThat(timeInHHMM).isEqualTo("02:35");  
+    }
+
+    @Test
+    public void givenInterval_whenFormatUsingDuration_thenFormatDuration() {
         Duration duration = Duration.ofMillis(38114000);
         long seconds = duration.getSeconds();
         long HH = seconds / 3600;
@@ -32,16 +41,15 @@ public void givenInterval_WhenFormatUsingDuration_formatDuration() {
         String timeInHHMMSS =  String.format("%02d:%02d:%02d", HH, MM, SS);
         assertThat(timeInHHMMSS).isEqualTo("10:35:14");
     }
-
-
+    
     @Test
-    public void givenInterval_WhenFormatDurationUsingApacheCommons_formatDuration() {
+    public void givenInterval_whenFormatDurationUsingApacheCommons_thenFormatDuration() {
         assertThat(DurationFormatUtils.formatDuration(38114000, "HH:mm:ss"))
           .isEqualTo("10:35:14");
     }
 
     @Test
-    public void givenInterval_WhenFormatDurationUsingJodaTime_formatDuration() {
+    public void givenInterval_whenFormatDurationUsingJodaTime_thenFormatDuration() {
         org.joda.time.Duration duration = new org.joda.time.Duration(38114000);
         Period period = duration.toPeriod();
         long HH = period.getHours();

core-java-modules/core-java-datetime-string-2/src/test/java/com/baeldung/formatduration/FormatDurationUnitTest.java

@@ -1,2 +1,3 @@
 test-link*
-0.*
+0.*
+src/test/resources/iostreams/TestFile.txt

core-java-modules/core-java-io-4/.gitignore

@@ -0,0 +1 @@
+src/test/resources/data_output.txt