POI：Add test which reproduces bug 58325, seems the file uses AlternateContent which POI does not support (yet)

testcases/ooxml/XSSF/UserModel/TestUnfixedBugs.cs

@@ -11,6 +11,7 @@ using NPOI.OpenXmlFormats.Spreadsheet;
 using NPOI.HSSF.UserModel;
 using System.Globalization;
 using NPOI.XSSF.Streaming;
+using NPOI.SS.Util;
 
 namespace NPOI.XSSF.UserModel
 {
@@ -175,6 +176,236 @@ namespace NPOI.XSSF.UserModel
             }
             wb.Close();
         }
+
+        // When this is fixed, the test case should go to BaseTestXCell with 
+        // adjustments to use _testDataProvider to also verify this for XSSF
+        [Test]
+        public void TestBug57294()
+        {
+            IWorkbook wb = SXSSFITestDataProvider.instance.CreateWorkbook();
+
+            ISheet sheet = wb.CreateSheet();
+            IRow row = sheet.CreateRow(0);
+            ICell cell = row.CreateCell(0);
+
+            IRichTextString str = new XSSFRichTextString("Test rich text string");
+            str.ApplyFont(2, 4, (short)0);
+            Assert.AreEqual(3, str.NumFormattingRuns);
+            cell.SetCellValue(str);
+
+            IWorkbook wbBack = SXSSFITestDataProvider.instance.WriteOutAndReadBack(wb);
+            wb.Close();
+
+            // re-read after serializing and reading back
+            ICell cellBack = wbBack.GetSheetAt(0).GetRow(0).GetCell(0);
+            Assert.IsNotNull(cellBack);
+            IRichTextString strBack = cellBack.RichStringCellValue;
+            Assert.IsNotNull(strBack);
+            Assert.AreEqual(3, strBack.NumFormattingRuns);
+            Assert.AreEqual(0, strBack.GetIndexOfFormattingRun(0));
+            Assert.AreEqual(2, strBack.GetIndexOfFormattingRun(1));
+            Assert.AreEqual(4, strBack.GetIndexOfFormattingRun(2));
+
+            wbBack.Close();
+        }
+        [Test]
+        public void TestBug55752()
+        {
+            IWorkbook wb = new XSSFWorkbook();
+            try
+            {
+                ISheet sheet = wb.CreateSheet("test");
+
+                for (int i = 0; i < 4; i++)
+                {
+                    IRow row = sheet.CreateRow(i);
+                    for (int j = 0; j < 2; j++)
+                    {
+                        ICell cell = row.CreateCell(j);
+                        cell.CellStyle = (wb.CreateCellStyle());
+                    }
+                }
+
+                // set content
+                IRow row1 = sheet.GetRow(0);
+                row1.GetCell(0).SetCellValue("AAA");
+                IRow row2 = sheet.GetRow(1);
+                row2.GetCell(0).SetCellValue("BBB");
+                IRow row3 = sheet.GetRow(2);
+                row3.GetCell(0).SetCellValue("CCC");
+                IRow row4 = sheet.GetRow(3);
+                row4.GetCell(0).SetCellValue("DDD");
+
+                // merge cells
+                CellRangeAddress range1 = new CellRangeAddress(0, 0, 0, 1);
+                sheet.AddMergedRegion(range1);
+                CellRangeAddress range2 = new CellRangeAddress(1, 1, 0, 1);
+                sheet.AddMergedRegion(range2);
+                CellRangeAddress range3 = new CellRangeAddress(2, 2, 0, 1);
+                sheet.AddMergedRegion(range3);
+                Assert.AreEqual(0, range3.FirstColumn);
+                Assert.AreEqual(1, range3.LastColumn);
+                Assert.AreEqual(2, range3.LastRow);
+                CellRangeAddress range4 = new CellRangeAddress(3, 3, 0, 1);
+                sheet.AddMergedRegion(range4);
+
+                // set border
+                RegionUtil.SetBorderBottom((int)BorderStyle.Thin, range1, sheet, wb);
+
+                row2.GetCell(0).CellStyle.BorderBottom = BorderStyle.Thin;
+                row2.GetCell(1).CellStyle.BorderBottom = BorderStyle.Thin;
+                ICell cell0 = CellUtil.GetCell(row3, 0);
+                CellUtil.SetCellStyleProperty(cell0, wb, CellUtil.BORDER_BOTTOM, BorderStyle.Thin);
+                ICell cell1 = CellUtil.GetCell(row3, 1);
+                CellUtil.SetCellStyleProperty(cell1, wb, CellUtil.BORDER_BOTTOM, BorderStyle.Thin);
+                RegionUtil.SetBorderBottom((int)BorderStyle.Thin, range4, sheet, wb);
+
+                // write to file
+                Stream stream = new FileStream("C:/temp/55752.xlsx", FileMode.Create, FileAccess.ReadWrite);
+                try
+                {
+                    wb.Write(stream);
+                }
+                finally
+                {
+                    stream.Close();
+                }
+            }
+            finally
+            {
+                wb.Close();
+            }
+        }
+        [Test]
+        public void Test57423()
+        {
+            IWorkbook wb = XSSFTestDataSamples.OpenSampleWorkbook("57423.xlsx");
+
+            ISheet testSheet = wb.GetSheetAt(0);
+            // row shift (negative or positive) causes corrupted output xlsx file when the shift value is bigger 
+            // than the number of rows being shifted 
+            // Excel 2010 on opening the output file says:
+            // "Excel found unreadable content" and offers recovering the file by removing the unreadable content
+            // This can be observed in cases like the following:
+            // negative shift of 1 row by less than -1
+            // negative shift of 2 rows by less than -2
+            // positive shift of 1 row by 2 or more 
+            // positive shift of 2 rows by 3 or more
+
+            //testSheet.shiftRows(4, 5, -3);
+            testSheet.ShiftRows(10, 10, 2);
+
+            checkRows57423(testSheet);
+
+            IWorkbook wbBack = XSSFTestDataSamples.WriteOutAndReadBack(wb);
+            /*FileOutputStream stream = new FileOutputStream("C:\\temp\\57423.xlsx");
+            try {
+                wb.write(stream);
+            } finally {
+                stream.close();
+            }*/
+            wb.Close();
+
+            checkRows57423(wbBack.GetSheetAt(0));
+
+            wbBack.Close();
+        }
+        private void checkRows57423(ISheet testSheet)
+        {
+            checkRow57423(testSheet, 0, "0");
+            checkRow57423(testSheet, 1, "1");
+            checkRow57423(testSheet, 2, "2");
+            checkRow57423(testSheet, 3, "3");
+            checkRow57423(testSheet, 4, "4");
+            checkRow57423(testSheet, 5, "5");
+            checkRow57423(testSheet, 6, "6");
+            checkRow57423(testSheet, 7, "7");
+            checkRow57423(testSheet, 8, "8");
+            checkRow57423(testSheet, 9, "9");
+
+            Assert.IsNull(testSheet.GetRow(10),
+                "Row number 10 should be gone after the shift");
+
+            checkRow57423(testSheet, 11, "11");
+            checkRow57423(testSheet, 12, "10");
+            checkRow57423(testSheet, 13, "13");
+            checkRow57423(testSheet, 14, "14");
+            checkRow57423(testSheet, 15, "15");
+            checkRow57423(testSheet, 16, "16");
+            checkRow57423(testSheet, 17, "17");
+            checkRow57423(testSheet, 18, "18");
+
+            ByteArrayOutputStream stream = new ByteArrayOutputStream();
+            try
+            {
+                ((XSSFSheet)testSheet).Write(stream);
+            }
+            finally
+            {
+                stream.Close();
+            }
+
+            // verify that the resulting XML has the rows in correct order as required by Excel
+            String xml = Encoding.UTF8.GetString(stream.ToByteArray());
+            int posR12 = xml.IndexOf("<row r=\"12\"");
+            int posR13 = xml.IndexOf("<row r=\"13\"");
+
+            // both need to be found
+            Assert.IsTrue(posR12 != -1);
+            Assert.IsTrue(posR13 != -1);
+
+            Assert.IsTrue(posR12 < posR13,
+                "Need to find row 12 before row 13 after the shifting, but had row 12 at " + posR12 + " and row 13 at " + posR13);
+        }
+        private void checkRow57423(ISheet testSheet, int rowNum, String contents)
+        {
+            IRow row = testSheet.GetRow(rowNum);
+            Assert.IsNotNull(row, "Expecting row at rownum " + rowNum);
+
+            CT_Row ctRow = ((XSSFRow)row).GetCTRow();
+            Assert.AreEqual(rowNum + 1, ctRow.r);
+
+            ICell cell = row.GetCell(0);
+            Assert.IsNotNull(cell, "Expecting cell at rownum " + rowNum);
+            Assert.AreEqual(contents + ".0", cell.ToString(),
+                "Did not have expected contents at rownum " + rowNum);
+        }
+
+        [Test]
+        public void test58325_one()
+        {
+            check58325(XSSFTestDataSamples.OpenSampleWorkbook("58325_lt.xlsx"), 1);
+        }
+        [Test]
+        public void test58325_three()
+        {
+            check58325(XSSFTestDataSamples.OpenSampleWorkbook("58325_db.xlsx"), 3);
+        }
+        private void check58325(XSSFWorkbook wb, int expectedShapes)
+        {
+            XSSFSheet sheet = wb.GetSheet("MetasNM001") as XSSFSheet;
+            Assert.IsNotNull(sheet);
+            StringBuilder str = new StringBuilder();
+            str.Append("sheet " + sheet.SheetName + " - ");
+            XSSFDrawing drawing = sheet.GetDrawingPatriarch();
+            //drawing = ((XSSFSheet)sheet).createDrawingPatriarch();
+            List<XSSFShape> shapes = drawing.GetShapes();
+            str.Append("drawing.Shapes.size() = " + shapes.Count);
+            IEnumerator<XSSFShape> it = shapes.GetEnumerator();
+            while (it.MoveNext())
+            {
+                XSSFShape shape = it.Current;
+                str.Append(", " + shape.ToString());
+                str.Append(", Col1:" + ((XSSFClientAnchor)shape.GetAnchor()).Col1);
+                str.Append(", Col2:" + ((XSSFClientAnchor)shape.GetAnchor()).Col2);
+                str.Append(", Row1:" + ((XSSFClientAnchor)shape.GetAnchor()).Row1);
+                str.Append(", Row2:" + ((XSSFClientAnchor)shape.GetAnchor()).Row2);
+            }
+
+            Assert.AreEqual(expectedShapes, shapes.Count, 
+                "Having shapes: " + str);
+        }
+
     }
 }