545 lines
22 KiB
Java
545 lines
22 KiB
Java
/* ====================================================================
|
|
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.poi.xssf.usermodel;
|
|
|
|
import java.io.IOException;
|
|
import java.util.TreeMap;
|
|
|
|
import junit.framework.TestCase;
|
|
|
|
import org.apache.poi.ss.usermodel.Cell;
|
|
import org.apache.poi.ss.usermodel.Row;
|
|
import org.apache.poi.ss.usermodel.Sheet;
|
|
import org.apache.poi.xssf.XSSFTestDataSamples;
|
|
import org.apache.poi.xssf.model.StylesTable;
|
|
import org.junit.Test;
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont;
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRPrElt;
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTRst;
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STXstring;
|
|
|
|
/**
|
|
* Tests functionality of the XSSFRichTextRun object
|
|
*
|
|
* @author Yegor Kozlov
|
|
*/
|
|
public final class TestXSSFRichTextString extends TestCase {
|
|
|
|
public void testCreate() {
|
|
XSSFRichTextString rt = new XSSFRichTextString("Apache POI");
|
|
assertEquals("Apache POI", rt.getString());
|
|
assertEquals(false, rt.hasFormatting());
|
|
|
|
CTRst st = rt.getCTRst();
|
|
assertTrue(st.isSetT());
|
|
assertEquals("Apache POI", st.getT());
|
|
assertEquals(false, rt.hasFormatting());
|
|
|
|
rt.append(" is cool stuff");
|
|
assertEquals(2, st.sizeOfRArray());
|
|
assertFalse(st.isSetT());
|
|
|
|
assertEquals("Apache POI is cool stuff", rt.getString());
|
|
assertEquals(false, rt.hasFormatting());
|
|
}
|
|
|
|
public void testEmpty() {
|
|
XSSFRichTextString rt = new XSSFRichTextString();
|
|
assertEquals(0, rt.getIndexOfFormattingRun(9999));
|
|
assertEquals(-1, rt.getLengthOfFormattingRun(9999));
|
|
assertNull(rt.getFontAtIndex(9999));
|
|
}
|
|
|
|
public void testApplyFont() {
|
|
XSSFRichTextString rt = new XSSFRichTextString();
|
|
rt.append("123");
|
|
rt.append("4567");
|
|
rt.append("89");
|
|
|
|
assertEquals("123456789", rt.getString());
|
|
assertEquals(false, rt.hasFormatting());
|
|
|
|
XSSFFont font1 = new XSSFFont();
|
|
font1.setBold(true);
|
|
|
|
rt.applyFont(2, 5, font1);
|
|
assertEquals(true, rt.hasFormatting());
|
|
|
|
assertEquals(4, rt.numFormattingRuns());
|
|
assertEquals(0, rt.getIndexOfFormattingRun(0));
|
|
assertEquals("12", rt.getCTRst().getRArray(0).getT());
|
|
|
|
assertEquals(2, rt.getIndexOfFormattingRun(1));
|
|
assertEquals("345", rt.getCTRst().getRArray(1).getT());
|
|
|
|
assertEquals(5, rt.getIndexOfFormattingRun(2));
|
|
assertEquals(2, rt.getLengthOfFormattingRun(2));
|
|
assertEquals("67", rt.getCTRst().getRArray(2).getT());
|
|
|
|
assertEquals(7, rt.getIndexOfFormattingRun(3));
|
|
assertEquals(2, rt.getLengthOfFormattingRun(3));
|
|
assertEquals("89", rt.getCTRst().getRArray(3).getT());
|
|
|
|
|
|
assertEquals(-1, rt.getIndexOfFormattingRun(9999));
|
|
assertEquals(-1, rt.getLengthOfFormattingRun(9999));
|
|
assertNull(rt.getFontAtIndex(9999));
|
|
}
|
|
|
|
public void testApplyFontIndex() {
|
|
XSSFRichTextString rt = new XSSFRichTextString("Apache POI");
|
|
rt.applyFont(0, 10, (short)1);
|
|
|
|
rt.applyFont((short)1);
|
|
|
|
assertNotNull(rt.getFontAtIndex(0));
|
|
}
|
|
|
|
public void testApplyFontWithStyles() {
|
|
XSSFRichTextString rt = new XSSFRichTextString("Apache POI");
|
|
|
|
StylesTable tbl = new StylesTable();
|
|
rt.setStylesTableReference(tbl);
|
|
|
|
try {
|
|
rt.applyFont(0, 10, (short)1);
|
|
fail("Fails without styles in the table");
|
|
} catch (IndexOutOfBoundsException e) {
|
|
// expected
|
|
}
|
|
|
|
tbl.putFont(new XSSFFont());
|
|
rt.applyFont(0, 10, (short)1);
|
|
rt.applyFont((short)1);
|
|
}
|
|
|
|
public void testApplyFontException() {
|
|
XSSFRichTextString rt = new XSSFRichTextString("Apache POI");
|
|
|
|
rt.applyFont(0, 0, (short)1);
|
|
|
|
try {
|
|
rt.applyFont(11, 10, (short)1);
|
|
fail("Should catch Exception here");
|
|
} catch (IllegalArgumentException e) {
|
|
assertTrue(e.getMessage().contains("11"));
|
|
}
|
|
|
|
try {
|
|
rt.applyFont(-1, 10, (short)1);
|
|
fail("Should catch Exception here");
|
|
} catch (IllegalArgumentException e) {
|
|
assertTrue(e.getMessage().contains("-1"));
|
|
}
|
|
|
|
try {
|
|
rt.applyFont(0, 555, (short)1);
|
|
fail("Should catch Exception here");
|
|
} catch (IllegalArgumentException e) {
|
|
assertTrue(e.getMessage().contains("555"));
|
|
}
|
|
}
|
|
|
|
public void testClearFormatting() {
|
|
|
|
XSSFRichTextString rt = new XSSFRichTextString("Apache POI");
|
|
assertEquals("Apache POI", rt.getString());
|
|
assertEquals(false, rt.hasFormatting());
|
|
|
|
rt.clearFormatting();
|
|
|
|
CTRst st = rt.getCTRst();
|
|
assertTrue(st.isSetT());
|
|
assertEquals("Apache POI", rt.getString());
|
|
assertEquals(0, rt.numFormattingRuns());
|
|
assertEquals(false, rt.hasFormatting());
|
|
|
|
XSSFFont font = new XSSFFont();
|
|
font.setBold(true);
|
|
|
|
rt.applyFont(7, 10, font);
|
|
assertEquals(2, rt.numFormattingRuns());
|
|
assertEquals(true, rt.hasFormatting());
|
|
|
|
rt.clearFormatting();
|
|
|
|
assertEquals("Apache POI", rt.getString());
|
|
assertEquals(0, rt.numFormattingRuns());
|
|
assertEquals(false, rt.hasFormatting());
|
|
}
|
|
|
|
public void testGetFonts() {
|
|
|
|
XSSFRichTextString rt = new XSSFRichTextString();
|
|
|
|
XSSFFont font1 = new XSSFFont();
|
|
font1.setFontName("Arial");
|
|
font1.setItalic(true);
|
|
rt.append("The quick", font1);
|
|
|
|
XSSFFont font1$ = rt.getFontOfFormattingRun(0);
|
|
assertEquals(font1.getItalic(), font1$.getItalic());
|
|
assertEquals(font1.getFontName(), font1$.getFontName());
|
|
|
|
XSSFFont font2 = new XSSFFont();
|
|
font2.setFontName("Courier");
|
|
font2.setBold(true);
|
|
rt.append(" brown fox", font2);
|
|
|
|
XSSFFont font2$ = rt.getFontOfFormattingRun(1);
|
|
assertEquals(font2.getBold(), font2$.getBold());
|
|
assertEquals(font2.getFontName(), font2$.getFontName());
|
|
}
|
|
|
|
/**
|
|
* make sure we insert xml:space="preserve" attribute
|
|
* if a string has leading or trailing white spaces
|
|
*/
|
|
public void testPreserveSpaces() {
|
|
XSSFRichTextString rt = new XSSFRichTextString("Apache");
|
|
CTRst ct = rt.getCTRst();
|
|
STXstring xs = ct.xgetT();
|
|
assertEquals("<xml-fragment>Apache</xml-fragment>", xs.xmlText());
|
|
rt.setString(" Apache");
|
|
assertEquals("<xml-fragment xml:space=\"preserve\"> Apache</xml-fragment>", xs.xmlText());
|
|
|
|
rt.append(" POI");
|
|
rt.append(" ");
|
|
assertEquals(" Apache POI ", rt.getString());
|
|
assertEquals("<xml-fragment xml:space=\"preserve\"> Apache</xml-fragment>", rt.getCTRst().getRArray(0).xgetT().xmlText());
|
|
assertEquals("<xml-fragment xml:space=\"preserve\"> POI</xml-fragment>", rt.getCTRst().getRArray(1).xgetT().xmlText());
|
|
assertEquals("<xml-fragment xml:space=\"preserve\"> </xml-fragment>", rt.getCTRst().getRArray(2).xgetT().xmlText());
|
|
}
|
|
|
|
/**
|
|
* test that unicode representation_ xHHHH_ is properly processed
|
|
*/
|
|
public void testUtfDecode() throws IOException {
|
|
CTRst st = CTRst.Factory.newInstance();
|
|
st.setT("abc_x000D_2ef_x000D_");
|
|
XSSFRichTextString rt = new XSSFRichTextString(st);
|
|
//_x000D_ is converted into carriage return
|
|
assertEquals("abc\r2ef\r", rt.getString());
|
|
|
|
// Test Lowercase case
|
|
CTRst st2 = CTRst.Factory.newInstance();
|
|
st2.setT("abc_x000d_2ef_x000d_");
|
|
XSSFRichTextString rt2 = new XSSFRichTextString(st2);
|
|
assertEquals("abc\r2ef\r", rt2.getString());
|
|
}
|
|
|
|
public void testApplyFont_lowlevel(){
|
|
CTRst st = CTRst.Factory.newInstance();
|
|
String text = "Apache Software Foundation";
|
|
XSSFRichTextString str = new XSSFRichTextString(text);
|
|
assertEquals(26, text.length());
|
|
|
|
st.addNewR().setT(text);
|
|
|
|
TreeMap<Integer, CTRPrElt> formats = str.getFormatMap(st);
|
|
assertEquals(1, formats.size());
|
|
assertEquals(26, (int)formats.firstKey());
|
|
assertNull(formats.get( formats.firstKey() ));
|
|
|
|
CTRPrElt fmt1 = CTRPrElt.Factory.newInstance();
|
|
str.applyFont(formats, 0, 6, fmt1);
|
|
assertEquals(2, formats.size());
|
|
assertEquals("[6, 26]", formats.keySet().toString());
|
|
Object[] runs1 = formats.values().toArray();
|
|
assertSame(fmt1, runs1[0]);
|
|
assertSame(null, runs1[1]);
|
|
|
|
CTRPrElt fmt2 = CTRPrElt.Factory.newInstance();
|
|
str.applyFont(formats, 7, 15, fmt2);
|
|
assertEquals(4, formats.size());
|
|
assertEquals("[6, 7, 15, 26]", formats.keySet().toString());
|
|
Object[] runs2 = formats.values().toArray();
|
|
assertSame(fmt1, runs2[0]);
|
|
assertSame(null, runs2[1]);
|
|
assertSame(fmt2, runs2[2]);
|
|
assertSame(null, runs2[3]);
|
|
|
|
CTRPrElt fmt3 = CTRPrElt.Factory.newInstance();
|
|
str.applyFont(formats, 6, 7, fmt3);
|
|
assertEquals(4, formats.size());
|
|
assertEquals("[6, 7, 15, 26]", formats.keySet().toString());
|
|
Object[] runs3 = formats.values().toArray();
|
|
assertSame(fmt1, runs3[0]);
|
|
assertSame(fmt3, runs3[1]);
|
|
assertSame(fmt2, runs3[2]);
|
|
assertSame(null, runs3[3]);
|
|
|
|
CTRPrElt fmt4 = CTRPrElt.Factory.newInstance();
|
|
str.applyFont(formats, 0, 7, fmt4);
|
|
assertEquals(3, formats.size());
|
|
assertEquals("[7, 15, 26]", formats.keySet().toString());
|
|
Object[] runs4 = formats.values().toArray();
|
|
assertSame(fmt4, runs4[0]);
|
|
assertSame(fmt2, runs4[1]);
|
|
assertSame(null, runs4[2]);
|
|
|
|
CTRPrElt fmt5 = CTRPrElt.Factory.newInstance();
|
|
str.applyFont(formats, 0, 26, fmt5);
|
|
assertEquals(1, formats.size());
|
|
assertEquals("[26]", formats.keySet().toString());
|
|
Object[] runs5 = formats.values().toArray();
|
|
assertSame(fmt5, runs5[0]);
|
|
|
|
CTRPrElt fmt6 = CTRPrElt.Factory.newInstance();
|
|
str.applyFont(formats, 15, 26, fmt6);
|
|
assertEquals(2, formats.size());
|
|
assertEquals("[15, 26]", formats.keySet().toString());
|
|
Object[] runs6 = formats.values().toArray();
|
|
assertSame(fmt5, runs6[0]);
|
|
assertSame(fmt6, runs6[1]);
|
|
|
|
str.applyFont(formats, 0, 26, null);
|
|
assertEquals(1, formats.size());
|
|
assertEquals("[26]", formats.keySet().toString());
|
|
Object[] runs7 = formats.values().toArray();
|
|
assertSame(null, runs7[0]);
|
|
|
|
str.applyFont(formats, 15, 26, fmt6);
|
|
assertEquals(2, formats.size());
|
|
assertEquals("[15, 26]", formats.keySet().toString());
|
|
Object[] runs8 = formats.values().toArray();
|
|
assertSame(null, runs8[0]);
|
|
assertSame(fmt6, runs8[1]);
|
|
|
|
str.applyFont(formats, 15, 26, fmt5);
|
|
assertEquals(2, formats.size());
|
|
assertEquals("[15, 26]", formats.keySet().toString());
|
|
Object[] runs9 = formats.values().toArray();
|
|
assertSame(null, runs9[0]);
|
|
assertSame(fmt5, runs9[1]);
|
|
|
|
str.applyFont(formats, 2, 20, fmt6);
|
|
assertEquals(3, formats.size());
|
|
assertEquals("[2, 20, 26]", formats.keySet().toString());
|
|
Object[] runs10 = formats.values().toArray();
|
|
assertSame(null, runs10[0]);
|
|
assertSame(fmt6, runs10[1]);
|
|
assertSame(fmt5, runs10[2]);
|
|
|
|
str.applyFont(formats, 22, 24, fmt4);
|
|
assertEquals(5, formats.size());
|
|
assertEquals("[2, 20, 22, 24, 26]", formats.keySet().toString());
|
|
Object[] runs11 = formats.values().toArray();
|
|
assertSame(null, runs11[0]);
|
|
assertSame(fmt6, runs11[1]);
|
|
assertSame(fmt5, runs11[2]);
|
|
assertSame(fmt4, runs11[3]);
|
|
assertSame(fmt5, runs11[4]);
|
|
|
|
str.applyFont(formats, 0, 10, fmt1);
|
|
assertEquals(5, formats.size());
|
|
assertEquals("[10, 20, 22, 24, 26]", formats.keySet().toString());
|
|
Object[] runs12 = formats.values().toArray();
|
|
assertSame(fmt1, runs12[0]);
|
|
assertSame(fmt6, runs12[1]);
|
|
assertSame(fmt5, runs12[2]);
|
|
assertSame(fmt4, runs12[3]);
|
|
assertSame(fmt5, runs12[4]);
|
|
}
|
|
|
|
public void testApplyFont_usermodel(){
|
|
String text = "Apache Software Foundation";
|
|
XSSFRichTextString str = new XSSFRichTextString(text);
|
|
XSSFFont font1 = new XSSFFont();
|
|
XSSFFont font2 = new XSSFFont();
|
|
XSSFFont font3 = new XSSFFont();
|
|
str.applyFont(font1);
|
|
assertEquals(1, str.numFormattingRuns());
|
|
|
|
str.applyFont(0, 6, font1);
|
|
str.applyFont(6, text.length(), font2);
|
|
assertEquals(2, str.numFormattingRuns());
|
|
assertEquals("Apache", str.getCTRst().getRArray(0).getT());
|
|
assertEquals(" Software Foundation", str.getCTRst().getRArray(1).getT());
|
|
|
|
str.applyFont(15, 26, font3);
|
|
assertEquals(3, str.numFormattingRuns());
|
|
assertEquals("Apache", str.getCTRst().getRArray(0).getT());
|
|
assertEquals(" Software", str.getCTRst().getRArray(1).getT());
|
|
assertEquals(" Foundation", str.getCTRst().getRArray(2).getT());
|
|
|
|
str.applyFont(6, text.length(), font2);
|
|
assertEquals(2, str.numFormattingRuns());
|
|
assertEquals("Apache", str.getCTRst().getRArray(0).getT());
|
|
assertEquals(" Software Foundation", str.getCTRst().getRArray(1).getT());
|
|
}
|
|
|
|
public void testLineBreaks_bug48877() throws IOException{
|
|
|
|
XSSFFont font = new XSSFFont();
|
|
//noinspection deprecation
|
|
font.setBoldweight(XSSFFont.BOLDWEIGHT_BOLD);
|
|
font.setFontHeightInPoints((short) 14);
|
|
XSSFRichTextString str;
|
|
STXstring t1, t2, t3;
|
|
|
|
str = new XSSFRichTextString("Incorrect\nLine-Breaking");
|
|
str.applyFont(0, 8, font);
|
|
t1 = str.getCTRst().getRArray(0).xgetT();
|
|
t2 = str.getCTRst().getRArray(1).xgetT();
|
|
assertEquals("<xml-fragment>Incorrec</xml-fragment>", t1.xmlText());
|
|
assertEquals("<xml-fragment>t\nLine-Breaking</xml-fragment>", t2.xmlText());
|
|
|
|
str = new XSSFRichTextString("Incorrect\nLine-Breaking");
|
|
str.applyFont(0, 9, font);
|
|
t1 = str.getCTRst().getRArray(0).xgetT();
|
|
t2 = str.getCTRst().getRArray(1).xgetT();
|
|
assertEquals("<xml-fragment>Incorrect</xml-fragment>", t1.xmlText());
|
|
assertEquals("<xml-fragment xml:space=\"preserve\">\nLine-Breaking</xml-fragment>", t2.xmlText());
|
|
|
|
str = new XSSFRichTextString("Incorrect\n Line-Breaking");
|
|
str.applyFont(0, 9, font);
|
|
t1 = str.getCTRst().getRArray(0).xgetT();
|
|
t2 = str.getCTRst().getRArray(1).xgetT();
|
|
assertEquals("<xml-fragment>Incorrect</xml-fragment>", t1.xmlText());
|
|
assertEquals("<xml-fragment xml:space=\"preserve\">\n Line-Breaking</xml-fragment>", t2.xmlText());
|
|
|
|
str = new XSSFRichTextString("Tab\tseparated\n");
|
|
t1 = str.getCTRst().xgetT();
|
|
// trailing \n causes must be preserved
|
|
assertEquals("<xml-fragment xml:space=\"preserve\">Tab\tseparated\n</xml-fragment>", t1.xmlText());
|
|
|
|
str.applyFont(0, 3, font);
|
|
t1 = str.getCTRst().getRArray(0).xgetT();
|
|
t2 = str.getCTRst().getRArray(1).xgetT();
|
|
assertEquals("<xml-fragment>Tab</xml-fragment>", t1.xmlText());
|
|
assertEquals("<xml-fragment xml:space=\"preserve\">\tseparated\n</xml-fragment>", t2.xmlText());
|
|
|
|
str = new XSSFRichTextString("Tab\tseparated\n");
|
|
str.applyFont(0, 4, font);
|
|
t1 = str.getCTRst().getRArray(0).xgetT();
|
|
t2 = str.getCTRst().getRArray(1).xgetT();
|
|
assertEquals("<xml-fragment xml:space=\"preserve\">Tab\t</xml-fragment>", t1.xmlText());
|
|
assertEquals("<xml-fragment xml:space=\"preserve\">separated\n</xml-fragment>", t2.xmlText());
|
|
|
|
str = new XSSFRichTextString("\n\n\nNew Line\n\n");
|
|
str.applyFont(0, 3, font);
|
|
str.applyFont(11, 13, font);
|
|
t1 = str.getCTRst().getRArray(0).xgetT();
|
|
t2 = str.getCTRst().getRArray(1).xgetT();
|
|
t3 = str.getCTRst().getRArray(2).xgetT();
|
|
// YK: don't know why, but XmlBeans converts leading tab characters to spaces
|
|
assertEquals("<xml-fragment xml:space=\"preserve\">\n\n\n</xml-fragment>", t1.xmlText());
|
|
assertEquals("<xml-fragment>New Line</xml-fragment>", t2.xmlText());
|
|
assertEquals("<xml-fragment xml:space=\"preserve\">\n\n</xml-fragment>", t3.xmlText());
|
|
}
|
|
|
|
public void testBug56511() {
|
|
XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("56511.xlsx");
|
|
for (Sheet sheet : wb) {
|
|
int lastRow = sheet.getLastRowNum();
|
|
for (int rowIdx = sheet.getFirstRowNum(); rowIdx <= lastRow; rowIdx++) {
|
|
Row row = sheet.getRow(rowIdx);
|
|
if(row != null) {
|
|
int lastCell = row.getLastCellNum();
|
|
|
|
for (int cellIdx = row.getFirstCellNum(); cellIdx <= lastCell; cellIdx++) {
|
|
|
|
Cell cell = row.getCell(cellIdx);
|
|
if (cell != null) {
|
|
//System.out.println("row " + rowIdx + " column " + cellIdx + ": " + cell.getCellType() + ": " + cell.toString());
|
|
|
|
XSSFRichTextString richText = (XSSFRichTextString) cell.getRichStringCellValue();
|
|
int anzFormattingRuns = richText.numFormattingRuns();
|
|
for (int run = 0; run < anzFormattingRuns; run++) {
|
|
/*XSSFFont font =*/ richText.getFontOfFormattingRun(run);
|
|
//System.out.println(" run " + run
|
|
// + " font " + (font == null ? "<null>" : font.getFontName()));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void testBug56511_values() {
|
|
XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("56511.xlsx");
|
|
Sheet sheet = wb.getSheetAt(0);
|
|
Row row = sheet.getRow(0);
|
|
|
|
// verify the values to ensure future changes keep the returned information equal
|
|
XSSFRichTextString rt = (XSSFRichTextString) row.getCell(0).getRichStringCellValue();
|
|
assertEquals(0, rt.numFormattingRuns());
|
|
assertNull(rt.getFontOfFormattingRun(0));
|
|
assertEquals(-1, rt.getLengthOfFormattingRun(0));
|
|
|
|
rt = (XSSFRichTextString) row.getCell(1).getRichStringCellValue();
|
|
assertEquals(0, row.getCell(1).getRichStringCellValue().numFormattingRuns());
|
|
assertNull(rt.getFontOfFormattingRun(1));
|
|
assertEquals(-1, rt.getLengthOfFormattingRun(1));
|
|
|
|
rt = (XSSFRichTextString) row.getCell(2).getRichStringCellValue();
|
|
assertEquals(2, rt.numFormattingRuns());
|
|
assertNotNull(rt.getFontOfFormattingRun(0));
|
|
assertEquals(4, rt.getLengthOfFormattingRun(0));
|
|
|
|
assertNotNull(rt.getFontOfFormattingRun(1));
|
|
assertEquals(9, rt.getLengthOfFormattingRun(1));
|
|
|
|
assertNull(rt.getFontOfFormattingRun(2));
|
|
|
|
rt = (XSSFRichTextString) row.getCell(3).getRichStringCellValue();
|
|
assertEquals(3, rt.numFormattingRuns());
|
|
assertNull(rt.getFontOfFormattingRun(0));
|
|
assertEquals(1, rt.getLengthOfFormattingRun(0));
|
|
|
|
assertNotNull(rt.getFontOfFormattingRun(1));
|
|
assertEquals(3, rt.getLengthOfFormattingRun(1));
|
|
|
|
assertNotNull(rt.getFontOfFormattingRun(2));
|
|
assertEquals(9, rt.getLengthOfFormattingRun(2));
|
|
}
|
|
|
|
public void testToString() {
|
|
XSSFRichTextString rt = new XSSFRichTextString("Apache POI");
|
|
assertNotNull(rt.toString());
|
|
|
|
// TODO: normally toString() should never return null, should we adjust this?
|
|
rt = new XSSFRichTextString();
|
|
assertNull(rt.toString());
|
|
}
|
|
|
|
public void test59008Font() {
|
|
XSSFFont font = new XSSFFont(CTFont.Factory.newInstance());
|
|
|
|
XSSFRichTextString rts = new XSSFRichTextString();
|
|
rts.append("This is correct ");
|
|
int s1 = rts.length();
|
|
rts.append("This is Bold Red", font);
|
|
int s2 = rts.length();
|
|
rts.append(" This uses the default font rather than the cell style font");
|
|
int s3 = rts.length();
|
|
|
|
assertEquals("<xml-fragment/>", rts.getFontAtIndex(s1-1).toString());
|
|
assertEquals(font, rts.getFontAtIndex(s2-1));
|
|
assertEquals("<xml-fragment/>", rts.getFontAtIndex(s3-1).toString());
|
|
}
|
|
|
|
public void test60289UtfDecode() throws IOException {
|
|
XSSFWorkbook wb = XSSFTestDataSamples.openSampleWorkbook("60289.xlsx");
|
|
assertEquals("Rich Text\r\nTest", wb.getSheetAt(0).getRow(1).getCell(1).getRichStringCellValue().getString());
|
|
wb.close();
|
|
}
|
|
}
|