From bce94fdfdffdf64e3755ca34ada17cd317ac0a23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8B=97=E6=B3=BD=E6=A5=A0?= Date: Sun, 18 Jan 2026 14:32:11 +0800 Subject: [PATCH 1/5] fix: fix error in using relativeHeadRowIndex for writing tables only(#794) --- .../sheet/write/executor/ExcelWriteAddExecutor.java | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java b/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java index 5715c88c1..13d2cdff0 100644 --- a/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java +++ b/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java @@ -42,6 +42,7 @@ import org.apache.fesod.sheet.write.metadata.CollectionRowData; import org.apache.fesod.sheet.write.metadata.MapRowData; import org.apache.fesod.sheet.write.metadata.RowData; +import org.apache.fesod.sheet.write.metadata.holder.AbstractWriteHolder; import org.apache.fesod.sheet.write.metadata.holder.WriteHolder; import org.apache.fesod.sheet.write.metadata.holder.WriteSheetHolder; import org.apache.poi.ss.usermodel.Cell; @@ -63,10 +64,15 @@ public void add(Collection data) { data = new ArrayList<>(); } WriteSheetHolder writeSheetHolder = writeContext.writeSheetHolder(); + WriteHolder currentWriteHolder = writeContext.currentWriteHolder(); int newRowIndex = writeSheetHolder.getNewRowIndexAndStartDoWrite(); - if (writeSheetHolder.isNew() - && !writeSheetHolder.getExcelWriteHeadProperty().hasHead()) { - newRowIndex += writeContext.currentWriteHolder().relativeHeadRowIndex(); + if (currentWriteHolder.isNew()) { + if(currentWriteHolder instanceof AbstractWriteHolder){ + AbstractWriteHolder writeHolder = (AbstractWriteHolder) currentWriteHolder; + if(!writeHolder.getExcelWriteHeadProperty().hasHead()){ + newRowIndex += currentWriteHolder.relativeHeadRowIndex(); + } + } } int relativeRowIndex = 0; for (Object oneRowData : data) { From d4c9711f603f9f887d98383c888bbe3cb27fe46e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8B=97=E6=B3=BD=E6=A5=A0?= Date: Sun, 18 Jan 2026 15:02:42 +0800 Subject: [PATCH 2/5] fix: fix error in using relativeHeadRowIndex for writing tables only(#794) Modify code format --- .../fesod/sheet/write/executor/ExcelWriteAddExecutor.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java b/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java index 13d2cdff0..8b1481eda 100644 --- a/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java +++ b/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java @@ -67,9 +67,9 @@ public void add(Collection data) { WriteHolder currentWriteHolder = writeContext.currentWriteHolder(); int newRowIndex = writeSheetHolder.getNewRowIndexAndStartDoWrite(); if (currentWriteHolder.isNew()) { - if(currentWriteHolder instanceof AbstractWriteHolder){ + if (currentWriteHolder instanceof AbstractWriteHolder) { AbstractWriteHolder writeHolder = (AbstractWriteHolder) currentWriteHolder; - if(!writeHolder.getExcelWriteHeadProperty().hasHead()){ + if (!writeHolder.getExcelWriteHeadProperty().hasHead()) { newRowIndex += currentWriteHolder.relativeHeadRowIndex(); } } From bb22044a0e601065c84c5e8b54848d818d8fa61a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8B=97=E6=B3=BD=E6=A5=A0?= Date: Sun, 17 May 2026 15:54:56 +0800 Subject: [PATCH 3/5] Modify style issues and add unit tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 苗泽楠 --- .../write/executor/ExcelWriteAddExecutor.java | 8 +- .../sheet/writesheet/WriteTableTest.java | 82 +++++++++++++++++++ 2 files changed, 85 insertions(+), 5 deletions(-) create mode 100644 fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java diff --git a/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java b/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java index e078b18af..1d9951094 100644 --- a/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java +++ b/fesod-sheet/src/main/java/org/apache/fesod/sheet/write/executor/ExcelWriteAddExecutor.java @@ -73,11 +73,9 @@ public void add(Collection data) { WriteHolder currentWriteHolder = writeContext.currentWriteHolder(); int newRowIndex = writeSheetHolder.getNewRowIndexAndStartDoWrite(); if (currentWriteHolder.isNew()) { - if (currentWriteHolder instanceof AbstractWriteHolder) { - AbstractWriteHolder writeHolder = (AbstractWriteHolder) currentWriteHolder; - if (!writeHolder.getExcelWriteHeadProperty().hasHead()) { - newRowIndex += currentWriteHolder.relativeHeadRowIndex(); - } + AbstractWriteHolder writeHolder = (AbstractWriteHolder) currentWriteHolder; + if (!writeHolder.getExcelWriteHeadProperty().hasHead()) { + newRowIndex += currentWriteHolder.relativeHeadRowIndex(); } } int relativeRowIndex = 0; diff --git a/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java b/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java new file mode 100644 index 000000000..c4b761c97 --- /dev/null +++ b/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java @@ -0,0 +1,82 @@ +package org.apache.fesod.sheet.writesheet; + +import org.apache.fesod.sheet.ExcelWriter; +import org.apache.fesod.sheet.FesodSheet; +import org.apache.fesod.sheet.support.ExcelTypeEnum; +import org.apache.fesod.sheet.util.TestFileUtil; +import org.apache.fesod.sheet.write.builder.ExcelWriterBuilder; +import org.apache.fesod.sheet.write.builder.ExcelWriterSheetBuilder; +import org.apache.fesod.sheet.write.metadata.WriteSheet; +import org.apache.fesod.sheet.write.metadata.WriteTable; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.*; + +public class WriteTableTest { + + @Test + public void testWriteTableWithTitle(){ + File testFile = TestFileUtil.createNewFile("writesheet/write-table" + ExcelTypeEnum.XLS.getValue()); + ExcelWriterBuilder write = FesodSheet.write(testFile); + + ExcelWriterSheetBuilder sheetBuilder = write.sheet(0, "0"); + WriteSheet sheet = sheetBuilder.build(); + + WriteTable tableA = sheetBuilder.table(0) + .head(WriteSheetData.class) + .relativeHeadRowIndex(3) + .build(); + + WriteTable tableB = sheetBuilder.table(1) + .relativeHeadRowIndex(6) + .head(WriteSheetData.class) + .build(); + + try (ExcelWriter writer = write.build()) { + writer.write(getList(), sheet, tableA); + + writer.write(getList(), sheet, tableB); + + writer.finish(); + } + } + + @Test + public void testWriteTableWithoutTitle() { + File testFile = TestFileUtil.createNewFile("writesheet/write-table" + ExcelTypeEnum.XLS.getValue()); + ExcelWriterBuilder write = FesodSheet.write(testFile); + ExcelWriterSheetBuilder sheetBuilder = write.sheet(0, "0"); + WriteSheet sheet = sheetBuilder.build(); + + WriteSheet collect = sheetBuilder + .relativeHeadRowIndex(1) + .build(); + + WriteTable tableA = sheetBuilder.table(0) + .relativeHeadRowIndex(3) + .build(); + + WriteTable tableB = sheetBuilder.table(1) + .relativeHeadRowIndex(6) + .build(); + + try (ExcelWriter writer = write.build()) { + writer.write(getList(), collect); + writer.write(getList(), sheet, tableA); + writer.write(getList(), sheet, tableB); + writer.finish(); + } + } + + private List getList(){ + Random random = new Random(); + List dataList = new ArrayList<>(); + for (int j = 0; j < 10; j++) { + WriteSheetData testA = new WriteSheetData(); + testA.setString(random.nextInt(100) + ""); + dataList.add(testA); + } + return dataList; + } +} From 9e4b31f6f05bff086e52a4ff9bb448ac468eb763 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8B=97=E6=B3=BD=E6=A5=A0?= Date: Sun, 7 Jun 2026 15:16:45 +0800 Subject: [PATCH 4/5] test: enhance WriteTableTest with parameterized assertions for XLS/XLSX MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add read-back verification via WorkbookFactory for both test cases - Parameterize with @EnumSource to cover both .xls and .xlsx formats - Use randomized offsets (0–9) and data sizes (1–10) for broader coverage - Replace non-deterministic Random data with predictable prefix‑index pattern - Resolve header string from @ExcelProperty annotation via reflection to avoid coupling to a hardcoded value in WriteSheetData - Calculate expected sequential row layout (tables are sequential, not overlapping; B's position = A's last row + offsetB + 1) Signed-off-by: 苗泽楠 --- .../sheet/writesheet/WriteTableTest.java | 235 +++++++++++++++--- 1 file changed, 199 insertions(+), 36 deletions(-) diff --git a/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java b/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java index c4b761c97..8e12bbe3c 100644 --- a/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java +++ b/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java @@ -2,80 +2,243 @@ import org.apache.fesod.sheet.ExcelWriter; import org.apache.fesod.sheet.FesodSheet; +import org.apache.fesod.sheet.annotation.ExcelProperty; import org.apache.fesod.sheet.support.ExcelTypeEnum; import org.apache.fesod.sheet.util.TestFileUtil; import org.apache.fesod.sheet.write.builder.ExcelWriterBuilder; import org.apache.fesod.sheet.write.builder.ExcelWriterSheetBuilder; import org.apache.fesod.sheet.write.metadata.WriteSheet; import org.apache.fesod.sheet.write.metadata.WriteTable; -import org.junit.jupiter.api.Test; +import org.apache.poi.ss.usermodel.*; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; import java.io.File; +import java.lang.reflect.Field; import java.util.*; public class WriteTableTest { - - @Test - public void testWriteTableWithTitle(){ - File testFile = TestFileUtil.createNewFile("writesheet/write-table" + ExcelTypeEnum.XLS.getValue()); + + private static final String HEADER_STRING; + + static { + try { + Field field = WriteSheetData.class.getDeclaredField("string"); + ExcelProperty annotation = field.getAnnotation(ExcelProperty.class); + HEADER_STRING = annotation.value()[0]; + } catch (Exception e) { + throw new RuntimeException( + "Failed to resolve @ExcelProperty header from WriteSheetData.string", e); + } + } + + @ParameterizedTest + @EnumSource(value = ExcelTypeEnum.class, names = {"XLS", "XLSX"}) + public void testWriteTableWithTitle(ExcelTypeEnum excelType) throws Exception { + Random random = new Random(); + int offsetA = random.nextInt(10); + int offsetB = random.nextInt(10); + int sizeA = random.nextInt(10)+1; + int sizeB = random.nextInt(10)+1; + + File testFile = TestFileUtil.createNewFile( + "writesheet/write-table-title" + excelType.getValue()); + + // ── write ──────────────────────────────────────────────────────────── + ExcelWriterBuilder write = FesodSheet.write(testFile); - ExcelWriterSheetBuilder sheetBuilder = write.sheet(0, "0"); WriteSheet sheet = sheetBuilder.build(); - + WriteTable tableA = sheetBuilder.table(0) .head(WriteSheetData.class) - .relativeHeadRowIndex(3) + .relativeHeadRowIndex(offsetA) .build(); - WriteTable tableB = sheetBuilder.table(1) - .relativeHeadRowIndex(6) + .relativeHeadRowIndex(offsetB) .head(WriteSheetData.class) .build(); - + try (ExcelWriter writer = write.build()) { - writer.write(getList(), sheet, tableA); - - writer.write(getList(), sheet, tableB); - + writer.write(getList(sizeA, "A-"), sheet, tableA); + writer.write(getList(sizeB, "B-"), sheet, tableB); writer.finish(); } + + Assertions.assertTrue(testFile.exists(), "Written file should exist"); + Assertions.assertTrue(testFile.length() > 0, "Written file should not be empty"); + + // ── read & assert ──────────────────────────────────────────────────── + + try (Workbook workbook = WorkbookFactory.create(testFile)) { + Sheet excelSheet = workbook.getSheetAt(0); + Assertions.assertNotNull(excelSheet, "Sheet '0' should exist"); + + Map expected = buildExpectedWithTitle(offsetA, offsetB, sizeA, sizeB); + int totalRows = expected.size(); + Assertions.assertEquals(totalRows, excelSheet.getPhysicalNumberOfRows(), + "Sheet should have exactly " + totalRows + " rows " + + "(offsets: A=" + offsetA + " B=" + offsetB + + ", sizes: A=" + sizeA + " B=" + sizeB + ")"); + + for (Map.Entry entry : expected.entrySet()) { + int rowIdx = entry.getKey(); + String expectedValue = entry.getValue(); + Row row = excelSheet.getRow(rowIdx); + Assertions.assertNotNull(row, + "Expected row " + rowIdx + " with value '" + expectedValue + + "' (A:" + offsetA + "/" + sizeA + + " B:" + offsetB + "/" + sizeB + ")"); + Cell cell = row.getCell(0); + Assertions.assertNotNull(cell, + "Expected cell at row " + rowIdx); + Assertions.assertEquals(expectedValue, cell.getStringCellValue(), + "Row " + rowIdx + " expected '" + expectedValue + "' " + + "(A:" + offsetA + "/" + sizeA + + " B:" + offsetB + "/" + sizeB + ")"); + } + } } - - @Test - public void testWriteTableWithoutTitle() { - File testFile = TestFileUtil.createNewFile("writesheet/write-table" + ExcelTypeEnum.XLS.getValue()); + + @ParameterizedTest + @EnumSource(value = ExcelTypeEnum.class, names = {"XLS", "XLSX"}) + public void testWriteTableWithoutTitle(ExcelTypeEnum excelType) throws Exception { + Random random = new Random(); + int offsetC = random.nextInt(10); + int offsetA = random.nextInt(10); + int offsetB = random.nextInt(10); + int sizeC = random.nextInt(10)+1; + int sizeA = random.nextInt(10)+1; + int sizeB = random.nextInt(10)+1; + + File testFile = TestFileUtil.createNewFile( + "writesheet/write-table-notitle" + excelType.getValue()); + + // ── write ──────────────────────────────────────────────────────────── + ExcelWriterBuilder write = FesodSheet.write(testFile); ExcelWriterSheetBuilder sheetBuilder = write.sheet(0, "0"); WriteSheet sheet = sheetBuilder.build(); - + WriteSheet collect = sheetBuilder - .relativeHeadRowIndex(1) + .relativeHeadRowIndex(offsetC) .build(); - WriteTable tableA = sheetBuilder.table(0) - .relativeHeadRowIndex(3) + .relativeHeadRowIndex(offsetA) .build(); - WriteTable tableB = sheetBuilder.table(1) - .relativeHeadRowIndex(6) + .relativeHeadRowIndex(offsetB) .build(); - + try (ExcelWriter writer = write.build()) { - writer.write(getList(), collect); - writer.write(getList(), sheet, tableA); - writer.write(getList(), sheet, tableB); + writer.write(getList(sizeC, "C-"), collect); + writer.write(getList(sizeA, "A-"), sheet, tableA); + writer.write(getList(sizeB, "B-"), sheet, tableB); writer.finish(); } + + Assertions.assertTrue(testFile.exists(), "Written file should exist"); + Assertions.assertTrue(testFile.length() > 0, "Written file should not be empty"); + + // ── read & assert ──────────────────────────────────────────────────── + + try (Workbook workbook = WorkbookFactory.create(testFile)) { + Sheet excelSheet = workbook.getSheetAt(0); + Assertions.assertNotNull(excelSheet, "Sheet '0' should exist"); + + Map expected = buildExpectedWithoutTitle( + offsetC, offsetA, offsetB, sizeC, sizeA, sizeB); + int totalRows = expected.size(); + Assertions.assertEquals(totalRows, excelSheet.getPhysicalNumberOfRows(), + "Sheet should have exactly " + totalRows + " rows " + + "(C:" + offsetC + "/" + sizeC + + " A:" + offsetA + "/" + sizeA + + " B:" + offsetB + "/" + sizeB + ")"); + + for (Map.Entry entry : expected.entrySet()) { + int rowIdx = entry.getKey(); + String expectedValue = entry.getValue(); + Row row = excelSheet.getRow(rowIdx); + Assertions.assertNotNull(row, + "Expected row " + rowIdx + " with value '" + expectedValue + + "' (C:" + offsetC + "/" + sizeC + + " A:" + offsetA + "/" + sizeA + + " B:" + offsetB + "/" + sizeB + ")"); + Cell cell = row.getCell(0); + Assertions.assertNotNull(cell, + "Expected cell at row " + rowIdx); + Assertions.assertEquals(expectedValue, cell.getStringCellValue(), + "Row " + rowIdx + " expected '" + expectedValue + "' " + + "(C:" + offsetC + "/" + sizeC + + " A:" + offsetA + "/" + sizeA + + " B:" + offsetB + "/" + sizeB + ")"); + } + } } - - private List getList(){ - Random random = new Random(); + + // ── expected-row builders ──────────────────────────────────────────────── + + /** + * Build expected row map for with-title tables. + * Tables are sequential: B starts after A's last row + offsetB empty rows. + */ + private static Map buildExpectedWithTitle( + int offsetA, int offsetB, int sizeA, int sizeB) { + Map expected = new LinkedHashMap<>(); + + // Table A: head at offsetA, data at offsetA+1 .. offsetA+sizeA + expected.put(offsetA, HEADER_STRING); + for (int i = 0; i < sizeA; i++) { + expected.put(offsetA + 1 + i, "A-" + i); + } + + // Table B: offsetB empty rows after A's last row, then head + data + int bHeadRow = offsetA + sizeA + offsetB + 1; + expected.put(bHeadRow, HEADER_STRING); + for (int i = 0; i < sizeB; i++) { + expected.put(bHeadRow + 1 + i, "B-" + i); + } + + return expected; + } + + /** + * Build expected row map for headerless writes. + * Tables are sequential: each starts after the previous one's last row + offset. + */ + private static Map buildExpectedWithoutTitle( + int offsetC, int offsetA, int offsetB, int sizeC, int sizeA, int sizeB) { + Map expected = new LinkedHashMap<>(); + + // collect: data at offsetC .. offsetC+sizeC-1 + for (int i = 0; i < sizeC; i++) { + expected.put(offsetC + i, "C-" + i); + } + + // tableA: starts after collect's last row + offsetA empty rows + int aStartRow = offsetC + sizeC + offsetA; + for (int i = 0; i < sizeA; i++) { + expected.put(aStartRow + i, "A-" + i); + } + + // tableB: starts after A's last row + offsetB empty rows + int bStartRow = aStartRow + sizeA + offsetB; + for (int i = 0; i < sizeB; i++) { + expected.put(bStartRow + i, "B-" + i); + } + + return expected; + } + + // ── helper ─────────────────────────────────────────────────────────────── + + private static List getList(int size, String prefix) { List dataList = new ArrayList<>(); - for (int j = 0; j < 10; j++) { - WriteSheetData testA = new WriteSheetData(); - testA.setString(random.nextInt(100) + ""); - dataList.add(testA); + for (int j = 0; j < size; j++) { + WriteSheetData data = new WriteSheetData(); + data.setString(prefix + j); + dataList.add(data); } return dataList; } From c262f780bbd58bf5b945bbcfd749cac0dc7e15f9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8B=97=E6=B3=BD=E6=A5=A0?= Date: Sun, 7 Jun 2026 15:22:21 +0800 Subject: [PATCH 5/5] test code format MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 苗泽楠 --- .../sheet/writesheet/WriteTableTest.java | 90 ++++++++++--------- 1 file changed, 46 insertions(+), 44 deletions(-) diff --git a/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java b/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java index 8e12bbe3c..5a47deeb4 100644 --- a/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java +++ b/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java @@ -1,5 +1,8 @@ package org.apache.fesod.sheet.writesheet; +import java.io.File; +import java.lang.reflect.Field; +import java.util.*; import org.apache.fesod.sheet.ExcelWriter; import org.apache.fesod.sheet.FesodSheet; import org.apache.fesod.sheet.annotation.ExcelProperty; @@ -14,10 +17,6 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; -import java.io.File; -import java.lang.reflect.Field; -import java.util.*; - public class WriteTableTest { private static final String HEADER_STRING; @@ -28,22 +27,22 @@ public class WriteTableTest { ExcelProperty annotation = field.getAnnotation(ExcelProperty.class); HEADER_STRING = annotation.value()[0]; } catch (Exception e) { - throw new RuntimeException( - "Failed to resolve @ExcelProperty header from WriteSheetData.string", e); + throw new RuntimeException("Failed to resolve @ExcelProperty header from WriteSheetData.string", e); } } @ParameterizedTest - @EnumSource(value = ExcelTypeEnum.class, names = {"XLS", "XLSX"}) + @EnumSource( + value = ExcelTypeEnum.class, + names = {"XLS", "XLSX"}) public void testWriteTableWithTitle(ExcelTypeEnum excelType) throws Exception { Random random = new Random(); int offsetA = random.nextInt(10); int offsetB = random.nextInt(10); - int sizeA = random.nextInt(10)+1; - int sizeB = random.nextInt(10)+1; + int sizeA = random.nextInt(10) + 1; + int sizeB = random.nextInt(10) + 1; - File testFile = TestFileUtil.createNewFile( - "writesheet/write-table-title" + excelType.getValue()); + File testFile = TestFileUtil.createNewFile("writesheet/write-table-title" + excelType.getValue()); // ── write ──────────────────────────────────────────────────────────── @@ -51,11 +50,13 @@ public void testWriteTableWithTitle(ExcelTypeEnum excelType) throws Exception { ExcelWriterSheetBuilder sheetBuilder = write.sheet(0, "0"); WriteSheet sheet = sheetBuilder.build(); - WriteTable tableA = sheetBuilder.table(0) + WriteTable tableA = sheetBuilder + .table(0) .head(WriteSheetData.class) .relativeHeadRowIndex(offsetA) .build(); - WriteTable tableB = sheetBuilder.table(1) + WriteTable tableB = sheetBuilder + .table(1) .relativeHeadRowIndex(offsetB) .head(WriteSheetData.class) .build(); @@ -77,7 +78,9 @@ public void testWriteTableWithTitle(ExcelTypeEnum excelType) throws Exception { Map expected = buildExpectedWithTitle(offsetA, offsetB, sizeA, sizeB); int totalRows = expected.size(); - Assertions.assertEquals(totalRows, excelSheet.getPhysicalNumberOfRows(), + Assertions.assertEquals( + totalRows, + excelSheet.getPhysicalNumberOfRows(), "Sheet should have exactly " + totalRows + " rows " + "(offsets: A=" + offsetA + " B=" + offsetB + ", sizes: A=" + sizeA + " B=" + sizeB + ")"); @@ -86,14 +89,16 @@ public void testWriteTableWithTitle(ExcelTypeEnum excelType) throws Exception { int rowIdx = entry.getKey(); String expectedValue = entry.getValue(); Row row = excelSheet.getRow(rowIdx); - Assertions.assertNotNull(row, + Assertions.assertNotNull( + row, "Expected row " + rowIdx + " with value '" + expectedValue + "' (A:" + offsetA + "/" + sizeA + " B:" + offsetB + "/" + sizeB + ")"); Cell cell = row.getCell(0); - Assertions.assertNotNull(cell, - "Expected cell at row " + rowIdx); - Assertions.assertEquals(expectedValue, cell.getStringCellValue(), + Assertions.assertNotNull(cell, "Expected cell at row " + rowIdx); + Assertions.assertEquals( + expectedValue, + cell.getStringCellValue(), "Row " + rowIdx + " expected '" + expectedValue + "' " + "(A:" + offsetA + "/" + sizeA + " B:" + offsetB + "/" + sizeB + ")"); @@ -102,18 +107,19 @@ public void testWriteTableWithTitle(ExcelTypeEnum excelType) throws Exception { } @ParameterizedTest - @EnumSource(value = ExcelTypeEnum.class, names = {"XLS", "XLSX"}) + @EnumSource( + value = ExcelTypeEnum.class, + names = {"XLS", "XLSX"}) public void testWriteTableWithoutTitle(ExcelTypeEnum excelType) throws Exception { Random random = new Random(); int offsetC = random.nextInt(10); int offsetA = random.nextInt(10); int offsetB = random.nextInt(10); - int sizeC = random.nextInt(10)+1; - int sizeA = random.nextInt(10)+1; - int sizeB = random.nextInt(10)+1; + int sizeC = random.nextInt(10) + 1; + int sizeA = random.nextInt(10) + 1; + int sizeB = random.nextInt(10) + 1; - File testFile = TestFileUtil.createNewFile( - "writesheet/write-table-notitle" + excelType.getValue()); + File testFile = TestFileUtil.createNewFile("writesheet/write-table-notitle" + excelType.getValue()); // ── write ──────────────────────────────────────────────────────────── @@ -121,15 +127,9 @@ public void testWriteTableWithoutTitle(ExcelTypeEnum excelType) throws Exception ExcelWriterSheetBuilder sheetBuilder = write.sheet(0, "0"); WriteSheet sheet = sheetBuilder.build(); - WriteSheet collect = sheetBuilder - .relativeHeadRowIndex(offsetC) - .build(); - WriteTable tableA = sheetBuilder.table(0) - .relativeHeadRowIndex(offsetA) - .build(); - WriteTable tableB = sheetBuilder.table(1) - .relativeHeadRowIndex(offsetB) - .build(); + WriteSheet collect = sheetBuilder.relativeHeadRowIndex(offsetC).build(); + WriteTable tableA = sheetBuilder.table(0).relativeHeadRowIndex(offsetA).build(); + WriteTable tableB = sheetBuilder.table(1).relativeHeadRowIndex(offsetB).build(); try (ExcelWriter writer = write.build()) { writer.write(getList(sizeC, "C-"), collect); @@ -147,10 +147,11 @@ public void testWriteTableWithoutTitle(ExcelTypeEnum excelType) throws Exception Sheet excelSheet = workbook.getSheetAt(0); Assertions.assertNotNull(excelSheet, "Sheet '0' should exist"); - Map expected = buildExpectedWithoutTitle( - offsetC, offsetA, offsetB, sizeC, sizeA, sizeB); + Map expected = buildExpectedWithoutTitle(offsetC, offsetA, offsetB, sizeC, sizeA, sizeB); int totalRows = expected.size(); - Assertions.assertEquals(totalRows, excelSheet.getPhysicalNumberOfRows(), + Assertions.assertEquals( + totalRows, + excelSheet.getPhysicalNumberOfRows(), "Sheet should have exactly " + totalRows + " rows " + "(C:" + offsetC + "/" + sizeC + " A:" + offsetA + "/" + sizeA @@ -160,15 +161,17 @@ public void testWriteTableWithoutTitle(ExcelTypeEnum excelType) throws Exception int rowIdx = entry.getKey(); String expectedValue = entry.getValue(); Row row = excelSheet.getRow(rowIdx); - Assertions.assertNotNull(row, + Assertions.assertNotNull( + row, "Expected row " + rowIdx + " with value '" + expectedValue + "' (C:" + offsetC + "/" + sizeC + " A:" + offsetA + "/" + sizeA + " B:" + offsetB + "/" + sizeB + ")"); Cell cell = row.getCell(0); - Assertions.assertNotNull(cell, - "Expected cell at row " + rowIdx); - Assertions.assertEquals(expectedValue, cell.getStringCellValue(), + Assertions.assertNotNull(cell, "Expected cell at row " + rowIdx); + Assertions.assertEquals( + expectedValue, + cell.getStringCellValue(), "Row " + rowIdx + " expected '" + expectedValue + "' " + "(C:" + offsetC + "/" + sizeC + " A:" + offsetA + "/" + sizeA @@ -183,11 +186,10 @@ public void testWriteTableWithoutTitle(ExcelTypeEnum excelType) throws Exception * Build expected row map for with-title tables. * Tables are sequential: B starts after A's last row + offsetB empty rows. */ - private static Map buildExpectedWithTitle( - int offsetA, int offsetB, int sizeA, int sizeB) { + private static Map buildExpectedWithTitle(int offsetA, int offsetB, int sizeA, int sizeB) { Map expected = new LinkedHashMap<>(); - // Table A: head at offsetA, data at offsetA+1 .. offsetA+sizeA + // Table A: head at offsetA, data at offsetA+1 ... offsetA+sizeA expected.put(offsetA, HEADER_STRING); for (int i = 0; i < sizeA; i++) { expected.put(offsetA + 1 + i, "A-" + i); @@ -211,7 +213,7 @@ private static Map buildExpectedWithoutTitle( int offsetC, int offsetA, int offsetB, int sizeC, int sizeA, int sizeB) { Map expected = new LinkedHashMap<>(); - // collect: data at offsetC .. offsetC+sizeC-1 + // collect: data at offsetC ... offsetC+sizeC-1 for (int i = 0; i < sizeC; i++) { expected.put(offsetC + i, "C-" + i); }