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/8] 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/8] 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/8] 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/8] 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/8] 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); } From 9828283148ef4ed680a29e03193d97ea3421cad6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8B=97=E6=B3=BD=E6=A5=A0?= Date: Tue, 23 Jun 2026 22:28:48 +0800 Subject: [PATCH 6/8] add copyright header and change test code. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 苗泽楠 --- .../sheet/writesheet/WriteTableTest.java | 299 ++++++------------ 1 file changed, 95 insertions(+), 204 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 5a47deeb4..b91db34d6 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,247 +1,138 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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 + * + * http://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. + */ + package org.apache.fesod.sheet.writesheet; import java.io.File; -import java.lang.reflect.Field; import java.util.*; +import java.util.stream.Stream; +import lombok.Data; import org.apache.fesod.sheet.ExcelWriter; import org.apache.fesod.sheet.FesodSheet; +import org.apache.fesod.sheet.annotation.ExcelIgnoreUnannotated; 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.apache.fesod.sheet.write.builder.ExcelWriterTableBuilder; 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 org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; public class WriteTableTest { - 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); - } + @Data + @ExcelIgnoreUnannotated + public static class WriteSheetData { + @ExcelProperty("Title") + private String string; } - @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 ──────────────────────────────────────────────────────────── + private static final List> OFFSETS = Arrays.asList( + Arrays.asList(0, 0, 0), Arrays.asList(0, 1, 3), Arrays.asList(1, 0, 2), Arrays.asList(2, 3, 0)); - ExcelWriterBuilder write = FesodSheet.write(testFile); - ExcelWriterSheetBuilder sheetBuilder = write.sheet(0, "0"); - WriteSheet sheet = sheetBuilder.build(); - - WriteTable tableA = sheetBuilder - .table(0) - .head(WriteSheetData.class) - .relativeHeadRowIndex(offsetA) - .build(); - WriteTable tableB = sheetBuilder - .table(1) - .relativeHeadRowIndex(offsetB) - .head(WriteSheetData.class) - .build(); - - try (ExcelWriter writer = write.build()) { - 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 + ")"); - } - } + static Stream testData() { + return Stream.of(Arguments.of(ExcelTypeEnum.XLSX, OFFSETS), Arguments.of(ExcelTypeEnum.XLS, OFFSETS)); } @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(); + @MethodSource("testData") + public void testWriteTable(ExcelTypeEnum excelType, List> offsets) throws Exception { + int n = offsets.size(); - WriteSheet collect = sheetBuilder.relativeHeadRowIndex(offsetC).build(); - WriteTable tableA = sheetBuilder.table(0).relativeHeadRowIndex(offsetA).build(); - WriteTable tableB = sheetBuilder.table(1).relativeHeadRowIndex(offsetB).build(); + File testFile = TestFileUtil.createNewFile("writesheet/write-table" + excelType.getValue()); - try (ExcelWriter writer = write.build()) { - writer.write(getList(sizeC, "C-"), collect); - writer.write(getList(sizeA, "A-"), sheet, tableA); - writer.write(getList(sizeB, "B-"), sheet, tableB); - writer.finish(); + try (ExcelWriter write = FesodSheet.write(testFile).excelType(excelType).build()) { + writeSheets(write, offsets, 0, "T", true); + writeSheets(write, offsets, n, "U", false); } 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 + ")"); + Iterator it = workbook.sheetIterator(); + for (int i = 0; i < n; i++) { + Assertions.assertTrue(it.hasNext(), "titled sheet " + i + " should exist"); + verifyRows(it.next(), true, offsets.get(i)); + } + for (int i = 0; i < n; i++) { + Assertions.assertTrue(it.hasNext(), "untitled sheet " + i + " should exist"); + verifyRows(it.next(), false, offsets.get(i)); } } } - // ── 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); + private static void writeSheets( + ExcelWriter write, List> offsets, int startSheetNo, String namePrefix, boolean isTitled) { + int n = offsets.size(); + for (int i = 0; i < n; i++) { + ExcelWriterSheetBuilder sheet = + FesodSheet.writerSheet().sheetNo(startSheetNo + i).sheetName(namePrefix + i); + List rowOffsets = offsets.get(i); + for (int j = 0; j < rowOffsets.size(); j++) { + ExcelWriterTableBuilder table = FesodSheet.writerTable() + .relativeHeadRowIndex(rowOffsets.get(j)) + .tableNo(j); + if (isTitled) { + table.head(WriteSheetData.class); + } + write.write(getList((char) ('A' + j)), sheet.build(), table.build()); + } } - - 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); + private static void verifyRows(Sheet sheet, boolean isTitled, List offsets) { + int rowIdx = 0; + char prefix = 'A'; + for (int offset : offsets) { + if (isTitled) { + Row headerRow = sheet.getRow(rowIdx + offset); + Assertions.assertNotNull(headerRow, "Header row " + (rowIdx + offset) + " missing"); + Assertions.assertEquals( + "Title", + headerRow.getCell(0).getStringCellValue(), + "Row " + (rowIdx + offset) + " should be header"); + rowIdx += offset + 1; + } else { + rowIdx += offset; + } + for (int j = 0; j < 2; j++) { + Row row = sheet.getRow(rowIdx + j); + Assertions.assertNotNull(row, "Data row " + (rowIdx + j) + " missing"); + Assertions.assertEquals( + prefix + "-" + j, row.getCell(0).getStringCellValue(), "Row " + (rowIdx + j) + " mismatch"); + } + rowIdx += 2; + prefix++; } - - return expected; } - // ── helper ─────────────────────────────────────────────────────────────── - - private static List getList(int size, String prefix) { - List dataList = new ArrayList<>(); - for (int j = 0; j < size; j++) { - WriteSheetData data = new WriteSheetData(); - data.setString(prefix + j); - dataList.add(data); + private static List getList(char prefix) { + List list = new ArrayList<>(); + for (int j = 0; j < 2; j++) { + WriteSheetData d = new WriteSheetData(); + d.setString(prefix + "-" + j); + list.add(d); } - return dataList; + return list; } } From 8f0fa296f4fec57336b275cc057ecc918b3814fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8B=97=E6=B3=BD=E6=A5=A0?= Date: Wed, 24 Jun 2026 12:06:48 +0800 Subject: [PATCH 7/8] Avoid using import * MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 苗泽楠 --- .../apache/fesod/sheet/writesheet/WriteTableTest.java | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 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 b91db34d6..d117170fa 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 @@ -20,7 +20,10 @@ package org.apache.fesod.sheet.writesheet; import java.io.File; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; import java.util.stream.Stream; import lombok.Data; import org.apache.fesod.sheet.ExcelWriter; @@ -31,7 +34,10 @@ import org.apache.fesod.sheet.util.TestFileUtil; import org.apache.fesod.sheet.write.builder.ExcelWriterSheetBuilder; import org.apache.fesod.sheet.write.builder.ExcelWriterTableBuilder; -import org.apache.poi.ss.usermodel.*; +import org.apache.poi.ss.usermodel.Row; +import org.apache.poi.ss.usermodel.Sheet; +import org.apache.poi.ss.usermodel.Workbook; +import org.apache.poi.ss.usermodel.WorkbookFactory; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; From f9d24199c2d1dd3b8fd3e68d009ac92ebedfca15 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=8B=97=E6=B3=BD=E6=A5=A0?= Date: Fri, 26 Jun 2026 19:07:45 +0800 Subject: [PATCH 8/8] remove import TestFileUtil MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: 苗泽楠 --- .../{writesheet => sheet}/WriteTableTest.java | 21 ++++++++++++------- 1 file changed, 13 insertions(+), 8 deletions(-) rename fesod-sheet/src/test/java/org/apache/fesod/sheet/{writesheet => sheet}/WriteTableTest.java (88%) 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/sheet/WriteTableTest.java similarity index 88% rename from fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java rename to fesod-sheet/src/test/java/org/apache/fesod/sheet/sheet/WriteTableTest.java index d117170fa..05d0b6376 100644 --- a/fesod-sheet/src/test/java/org/apache/fesod/sheet/writesheet/WriteTableTest.java +++ b/fesod-sheet/src/test/java/org/apache/fesod/sheet/sheet/WriteTableTest.java @@ -17,7 +17,7 @@ * under the License. */ -package org.apache.fesod.sheet.writesheet; +package org.apache.fesod.sheet.sheet; import java.io.File; import java.util.ArrayList; @@ -30,8 +30,9 @@ import org.apache.fesod.sheet.FesodSheet; import org.apache.fesod.sheet.annotation.ExcelIgnoreUnannotated; 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.testkit.Tags; +import org.apache.fesod.sheet.testkit.base.AbstractExcelTest; +import org.apache.fesod.sheet.testkit.enums.ExcelFormat; import org.apache.fesod.sheet.write.builder.ExcelWriterSheetBuilder; import org.apache.fesod.sheet.write.builder.ExcelWriterTableBuilder; import org.apache.poi.ss.usermodel.Row; @@ -39,11 +40,13 @@ import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.ss.usermodel.WorkbookFactory; import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Tag; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; -public class WriteTableTest { +@Tag(Tags.ROUND_TRIP) +public class WriteTableTest extends AbstractExcelTest { @Data @ExcelIgnoreUnannotated @@ -56,17 +59,19 @@ public static class WriteSheetData { Arrays.asList(0, 0, 0), Arrays.asList(0, 1, 3), Arrays.asList(1, 0, 2), Arrays.asList(2, 3, 0)); static Stream testData() { - return Stream.of(Arguments.of(ExcelTypeEnum.XLSX, OFFSETS), Arguments.of(ExcelTypeEnum.XLS, OFFSETS)); + return Stream.of(Arguments.of(ExcelFormat.XLSX, OFFSETS), Arguments.of(ExcelFormat.XLS, OFFSETS)); } @ParameterizedTest @MethodSource("testData") - public void testWriteTable(ExcelTypeEnum excelType, List> offsets) throws Exception { + public void testWriteTable(ExcelFormat excelFormat, List> offsets) throws Exception { int n = offsets.size(); - File testFile = TestFileUtil.createNewFile("writesheet/write-table" + excelType.getValue()); + File testFile = createTempFile(excelFormat); - try (ExcelWriter write = FesodSheet.write(testFile).excelType(excelType).build()) { + try (ExcelWriter write = FesodSheet.write(testFile) + .excelType(excelFormat.toExcelTypeEnum()) + .build()) { writeSheets(write, offsets, 0, "T", true); writeSheets(write, offsets, n, "U", false); }