2008-03-13 07:50:50 -04:00
|
|
|
/* ====================================================================
|
|
|
|
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 junit.framework.TestCase;
|
|
|
|
|
2010-09-20 16:10:14 -04:00
|
|
|
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
|
|
|
|
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
|
2008-09-24 13:53:29 -04:00
|
|
|
import org.apache.poi.ss.usermodel.CellStyle;
|
2008-10-28 06:03:51 -04:00
|
|
|
import org.apache.poi.ss.usermodel.HorizontalAlignment;
|
2010-09-20 16:10:14 -04:00
|
|
|
import org.apache.poi.ss.usermodel.IndexedColors;
|
|
|
|
import org.apache.poi.ss.usermodel.VerticalAlignment;
|
2011-04-21 09:22:18 -04:00
|
|
|
import org.apache.poi.xssf.XSSFTestDataSamples;
|
2008-03-16 20:10:17 -04:00
|
|
|
import org.apache.poi.xssf.model.StylesTable;
|
|
|
|
import org.apache.poi.xssf.usermodel.extensions.XSSFCellBorder;
|
2008-03-25 09:19:27 -04:00
|
|
|
import org.apache.poi.xssf.usermodel.extensions.XSSFCellFill;
|
2010-09-20 16:10:14 -04:00
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTBorder;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTCellXfs;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFill;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTFont;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTStylesheet;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.CTXf;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STBorderStyle;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STHorizontalAlignment;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STPatternType;
|
|
|
|
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STVerticalAlignment;
|
2008-03-13 07:50:50 -04:00
|
|
|
|
|
|
|
|
|
|
|
public class TestXSSFCellStyle extends TestCase {
|
2008-09-15 06:39:37 -04:00
|
|
|
|
2008-09-29 00:28:55 -04:00
|
|
|
private StylesTable stylesTable;
|
|
|
|
private CTBorder ctBorderA;
|
|
|
|
private CTFill ctFill;
|
|
|
|
private CTFont ctFont;
|
|
|
|
private CTXf cellStyleXf;
|
|
|
|
private CTXf cellXf;
|
|
|
|
private CTCellXfs cellXfs;
|
|
|
|
private XSSFCellStyle cellStyle;
|
|
|
|
private CTStylesheet ctStylesheet;
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected void setUp() {
|
|
|
|
stylesTable = new StylesTable();
|
2009-08-18 15:49:28 -04:00
|
|
|
|
2008-10-29 15:12:47 -04:00
|
|
|
ctStylesheet = stylesTable.getCTStylesheet();
|
2009-08-18 15:49:28 -04:00
|
|
|
|
2008-09-29 00:28:55 -04:00
|
|
|
ctBorderA = CTBorder.Factory.newInstance();
|
2011-03-18 11:18:45 -04:00
|
|
|
XSSFCellBorder borderA = new XSSFCellBorder(ctBorderA);
|
2008-09-29 00:28:55 -04:00
|
|
|
long borderId = stylesTable.putBorder(borderA);
|
|
|
|
assertEquals(1, borderId);
|
|
|
|
|
2011-03-18 11:18:45 -04:00
|
|
|
XSSFCellBorder borderB = new XSSFCellBorder();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(1, stylesTable.putBorder(borderB));
|
2008-09-29 00:28:55 -04:00
|
|
|
|
|
|
|
ctFill = CTFill.Factory.newInstance();
|
|
|
|
XSSFCellFill fill = new XSSFCellFill(ctFill);
|
|
|
|
long fillId = stylesTable.putFill(fill);
|
|
|
|
assertEquals(2, fillId);
|
|
|
|
|
|
|
|
ctFont = CTFont.Factory.newInstance();
|
|
|
|
XSSFFont font = new XSSFFont(ctFont);
|
|
|
|
long fontId = stylesTable.putFont(font);
|
|
|
|
assertEquals(1, fontId);
|
|
|
|
|
|
|
|
cellStyleXf = ctStylesheet.addNewCellStyleXfs().addNewXf();
|
|
|
|
cellStyleXf.setBorderId(1);
|
|
|
|
cellStyleXf.setFillId(1);
|
|
|
|
cellStyleXf.setFontId(1);
|
2009-08-18 15:49:28 -04:00
|
|
|
|
2008-09-29 00:28:55 -04:00
|
|
|
cellXfs = ctStylesheet.addNewCellXfs();
|
|
|
|
cellXf = cellXfs.addNewXf();
|
|
|
|
cellXf.setXfId(1);
|
|
|
|
cellXf.setBorderId(1);
|
|
|
|
cellXf.setFillId(1);
|
|
|
|
cellXf.setFontId(1);
|
|
|
|
stylesTable.putCellStyleXf(cellStyleXf);
|
|
|
|
stylesTable.putCellXf(cellXf);
|
2010-05-19 07:55:17 -04:00
|
|
|
cellStyle = new XSSFCellStyle(1, 1, stylesTable, null);
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderBottom() {
|
2008-10-05 09:56:28 -04:00
|
|
|
//default values
|
|
|
|
assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderBottom());
|
|
|
|
|
|
|
|
int num = stylesTable.getBorders().size();
|
|
|
|
cellStyle.setBorderBottom(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderBottom());
|
|
|
|
//a new border has been added
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
//id of the created border
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.MEDIUM, ctBorder.getBottom().getStyle());
|
|
|
|
|
|
|
|
num = stylesTable.getBorders().size();
|
|
|
|
//setting the same border multiple times should not change borderId
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
cellStyle.setBorderBottom(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderBottom());
|
|
|
|
}
|
|
|
|
assertEquals(borderId, cellStyle.getCoreXf().getBorderId());
|
|
|
|
assertEquals(num, stylesTable.getBorders().size());
|
|
|
|
assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());
|
|
|
|
|
|
|
|
//setting border to none removes the <bottom> element
|
|
|
|
cellStyle.setBorderBottom(CellStyle.BORDER_NONE);
|
|
|
|
assertEquals(num, stylesTable.getBorders().size());
|
|
|
|
borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertFalse(ctBorder.isSetBottom());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderRight() {
|
|
|
|
//default values
|
|
|
|
assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderRight());
|
|
|
|
|
|
|
|
int num = stylesTable.getBorders().size();
|
|
|
|
cellStyle.setBorderRight(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderRight());
|
|
|
|
//a new border has been added
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
//id of the created border
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.MEDIUM, ctBorder.getRight().getStyle());
|
|
|
|
|
|
|
|
num = stylesTable.getBorders().size();
|
|
|
|
//setting the same border multiple times should not change borderId
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
cellStyle.setBorderRight(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderRight());
|
|
|
|
}
|
|
|
|
assertEquals(borderId, cellStyle.getCoreXf().getBorderId());
|
|
|
|
assertEquals(num, stylesTable.getBorders().size());
|
|
|
|
assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());
|
|
|
|
|
|
|
|
//setting border to none removes the <right> element
|
|
|
|
cellStyle.setBorderRight(CellStyle.BORDER_NONE);
|
|
|
|
assertEquals(num, stylesTable.getBorders().size());
|
|
|
|
borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertFalse(ctBorder.isSetRight());
|
|
|
|
}
|
2008-09-29 00:28:55 -04:00
|
|
|
|
|
|
|
public void testGetSetBorderLeft() {
|
2008-10-05 09:56:28 -04:00
|
|
|
//default values
|
|
|
|
assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderLeft());
|
|
|
|
|
|
|
|
int num = stylesTable.getBorders().size();
|
|
|
|
cellStyle.setBorderLeft(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderLeft());
|
|
|
|
//a new border has been added
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
//id of the created border
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.MEDIUM, ctBorder.getLeft().getStyle());
|
|
|
|
|
|
|
|
num = stylesTable.getBorders().size();
|
|
|
|
//setting the same border multiple times should not change borderId
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
cellStyle.setBorderLeft(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderLeft());
|
|
|
|
}
|
|
|
|
assertEquals(borderId, cellStyle.getCoreXf().getBorderId());
|
|
|
|
assertEquals(num, stylesTable.getBorders().size());
|
|
|
|
assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());
|
|
|
|
|
|
|
|
//setting border to none removes the <left> element
|
|
|
|
cellStyle.setBorderLeft(CellStyle.BORDER_NONE);
|
|
|
|
assertEquals(num, stylesTable.getBorders().size());
|
|
|
|
borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertFalse(ctBorder.isSetLeft());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderTop() {
|
2008-10-05 09:56:28 -04:00
|
|
|
//default values
|
|
|
|
assertEquals(CellStyle.BORDER_NONE, cellStyle.getBorderTop());
|
|
|
|
|
|
|
|
int num = stylesTable.getBorders().size();
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop());
|
|
|
|
//a new border has been added
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
//id of the created border
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.MEDIUM, ctBorder.getTop().getStyle());
|
|
|
|
|
|
|
|
num = stylesTable.getBorders().size();
|
|
|
|
//setting the same border multiple times should not change borderId
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop());
|
|
|
|
}
|
|
|
|
assertEquals(borderId, cellStyle.getCoreXf().getBorderId());
|
|
|
|
assertEquals(num, stylesTable.getBorders().size());
|
|
|
|
assertSame(ctBorder, stylesTable.getBorderAt(borderId).getCTBorder());
|
|
|
|
|
|
|
|
//setting border to none removes the <top> element
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_NONE);
|
|
|
|
assertEquals(num, stylesTable.getBorders().size());
|
|
|
|
borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertFalse(ctBorder.isSetTop());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
2013-09-29 16:23:20 -04:00
|
|
|
public void testGetSetBorderThin() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_THIN);
|
|
|
|
assertEquals(CellStyle.BORDER_THIN, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.THIN, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderMedium() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.MEDIUM, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderThick() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_THICK);
|
|
|
|
assertEquals(CellStyle.BORDER_THICK, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.THICK, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderHair() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_HAIR);
|
|
|
|
assertEquals(CellStyle.BORDER_HAIR, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.HAIR, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderDotted() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_DOTTED);
|
|
|
|
assertEquals(CellStyle.BORDER_DOTTED, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.DOTTED, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderDashed() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_DASHED);
|
|
|
|
assertEquals(CellStyle.BORDER_DASHED, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.DASHED, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderDashDot() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_DASH_DOT);
|
|
|
|
assertEquals(CellStyle.BORDER_DASH_DOT, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.DASH_DOT, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderDashDotDot() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_DASH_DOT_DOT);
|
|
|
|
assertEquals(CellStyle.BORDER_DASH_DOT_DOT, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.DASH_DOT_DOT, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderMediumDashDot() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASH_DOT);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.MEDIUM_DASH_DOT, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderMediumDashDotDot() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASH_DOT_DOT);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM_DASH_DOT_DOT, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.MEDIUM_DASH_DOT_DOT, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderMediumDashed() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_MEDIUM_DASHED);
|
|
|
|
assertEquals(CellStyle.BORDER_MEDIUM_DASHED, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.MEDIUM_DASHED, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderSlantDashDot() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_SLANTED_DASH_DOT);
|
|
|
|
assertEquals(CellStyle.BORDER_SLANTED_DASH_DOT, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.SLANT_DASH_DOT, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetBorderDouble() {
|
|
|
|
cellStyle.setBorderTop(CellStyle.BORDER_DOUBLE);
|
|
|
|
assertEquals(CellStyle.BORDER_DOUBLE, cellStyle.getBorderTop());
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(STBorderStyle.DOUBLE, ctBorder.getTop().getStyle());
|
|
|
|
}
|
|
|
|
|
2008-09-29 00:28:55 -04:00
|
|
|
public void testGetSetBottomBorderColor() {
|
2008-10-05 09:56:28 -04:00
|
|
|
//defaults
|
|
|
|
assertEquals(IndexedColors.BLACK.getIndex(), cellStyle.getBottomBorderColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getBottomBorderXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
|
|
|
|
int num = stylesTable.getBorders().size();
|
|
|
|
|
|
|
|
XSSFColor clr;
|
|
|
|
|
|
|
|
//setting indexed color
|
|
|
|
cellStyle.setBottomBorderColor(IndexedColors.BLUE_GREY.getIndex());
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), cellStyle.getBottomBorderColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
clr = cellStyle.getBottomBorderXSSFColor();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertTrue(clr.getCTColor().isSetIndexed());
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), clr.getIndexed());
|
|
|
|
//a new border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
|
|
|
|
//id of the created border
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), ctBorder.getBottom().getColor().getIndexed());
|
|
|
|
|
|
|
|
//setting XSSFColor
|
|
|
|
num = stylesTable.getBorders().size();
|
|
|
|
clr = new XSSFColor(java.awt.Color.CYAN);
|
|
|
|
cellStyle.setBottomBorderColor(clr);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertEquals(clr.getCTColor().toString(), cellStyle.getBottomBorderXSSFColor().getCTColor().toString());
|
|
|
|
byte[] rgb = cellStyle.getBottomBorderXSSFColor().getRgb();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(java.awt.Color.CYAN, new java.awt.Color(rgb[0] & 0xFF, rgb[1] & 0xFF, rgb[2] & 0xFF));
|
|
|
|
//another border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
|
|
|
|
//passing null unsets the color
|
|
|
|
cellStyle.setBottomBorderColor(null);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getBottomBorderXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
}
|
2008-09-29 00:28:55 -04:00
|
|
|
|
|
|
|
public void testGetSetTopBorderColor() {
|
2008-10-05 09:56:28 -04:00
|
|
|
//defaults
|
|
|
|
assertEquals(IndexedColors.BLACK.getIndex(), cellStyle.getTopBorderColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getTopBorderXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
|
|
|
|
int num = stylesTable.getBorders().size();
|
|
|
|
|
|
|
|
XSSFColor clr;
|
|
|
|
|
|
|
|
//setting indexed color
|
|
|
|
cellStyle.setTopBorderColor(IndexedColors.BLUE_GREY.getIndex());
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), cellStyle.getTopBorderColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
clr = cellStyle.getTopBorderXSSFColor();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertTrue(clr.getCTColor().isSetIndexed());
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), clr.getIndexed());
|
|
|
|
//a new border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
|
|
|
|
//id of the created border
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), ctBorder.getTop().getColor().getIndexed());
|
|
|
|
|
|
|
|
//setting XSSFColor
|
|
|
|
num = stylesTable.getBorders().size();
|
|
|
|
clr = new XSSFColor(java.awt.Color.CYAN);
|
|
|
|
cellStyle.setTopBorderColor(clr);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertEquals(clr.getCTColor().toString(), cellStyle.getTopBorderXSSFColor().getCTColor().toString());
|
|
|
|
byte[] rgb = cellStyle.getTopBorderXSSFColor().getRgb();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(java.awt.Color.CYAN, new java.awt.Color(rgb[0] & 0xFF, rgb[1] & 0xFF, rgb[2] & 0xFF));
|
|
|
|
//another border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
|
|
|
|
//passing null unsets the color
|
|
|
|
cellStyle.setTopBorderColor(null);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getTopBorderXSSFColor());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetLeftBorderColor() {
|
2008-10-05 09:56:28 -04:00
|
|
|
//defaults
|
|
|
|
assertEquals(IndexedColors.BLACK.getIndex(), cellStyle.getLeftBorderColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getLeftBorderXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
|
|
|
|
int num = stylesTable.getBorders().size();
|
|
|
|
|
|
|
|
XSSFColor clr;
|
|
|
|
|
|
|
|
//setting indexed color
|
|
|
|
cellStyle.setLeftBorderColor(IndexedColors.BLUE_GREY.getIndex());
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), cellStyle.getLeftBorderColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
clr = cellStyle.getLeftBorderXSSFColor();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertTrue(clr.getCTColor().isSetIndexed());
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), clr.getIndexed());
|
|
|
|
//a new border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
|
|
|
|
//id of the created border
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), ctBorder.getLeft().getColor().getIndexed());
|
|
|
|
|
|
|
|
//setting XSSFColor
|
|
|
|
num = stylesTable.getBorders().size();
|
|
|
|
clr = new XSSFColor(java.awt.Color.CYAN);
|
|
|
|
cellStyle.setLeftBorderColor(clr);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertEquals(clr.getCTColor().toString(), cellStyle.getLeftBorderXSSFColor().getCTColor().toString());
|
|
|
|
byte[] rgb = cellStyle.getLeftBorderXSSFColor().getRgb();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(java.awt.Color.CYAN, new java.awt.Color(rgb[0] & 0xFF, rgb[1] & 0xFF, rgb[2] & 0xFF));
|
|
|
|
//another border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
|
|
|
|
//passing null unsets the color
|
|
|
|
cellStyle.setLeftBorderColor(null);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getLeftBorderXSSFColor());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetRightBorderColor() {
|
2008-10-05 09:56:28 -04:00
|
|
|
//defaults
|
|
|
|
assertEquals(IndexedColors.BLACK.getIndex(), cellStyle.getRightBorderColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getRightBorderXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
|
|
|
|
int num = stylesTable.getBorders().size();
|
|
|
|
|
|
|
|
XSSFColor clr;
|
|
|
|
|
|
|
|
//setting indexed color
|
|
|
|
cellStyle.setRightBorderColor(IndexedColors.BLUE_GREY.getIndex());
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), cellStyle.getRightBorderColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
clr = cellStyle.getRightBorderXSSFColor();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertTrue(clr.getCTColor().isSetIndexed());
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), clr.getIndexed());
|
|
|
|
//a new border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
|
|
|
|
//id of the created border
|
|
|
|
int borderId = (int)cellStyle.getCoreXf().getBorderId();
|
|
|
|
assertTrue(borderId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTBorder ctBorder = stylesTable.getBorderAt(borderId).getCTBorder();
|
|
|
|
assertEquals(IndexedColors.BLUE_GREY.getIndex(), ctBorder.getRight().getColor().getIndexed());
|
|
|
|
|
|
|
|
//setting XSSFColor
|
|
|
|
num = stylesTable.getBorders().size();
|
|
|
|
clr = new XSSFColor(java.awt.Color.CYAN);
|
|
|
|
cellStyle.setRightBorderColor(clr);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertEquals(clr.getCTColor().toString(), cellStyle.getRightBorderXSSFColor().getCTColor().toString());
|
|
|
|
byte[] rgb = cellStyle.getRightBorderXSSFColor().getRgb();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(java.awt.Color.CYAN, new java.awt.Color(rgb[0] & 0xFF, rgb[1] & 0xFF, rgb[2] & 0xFF));
|
|
|
|
//another border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getBorders().size());
|
|
|
|
|
|
|
|
//passing null unsets the color
|
|
|
|
cellStyle.setRightBorderColor(null);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getRightBorderXSSFColor());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
public void testGetSetFillBackgroundColor() {
|
|
|
|
|
|
|
|
assertEquals(IndexedColors.AUTOMATIC.getIndex(), cellStyle.getFillBackgroundColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getFillBackgroundXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
|
|
|
|
XSSFColor clr;
|
|
|
|
|
|
|
|
int num = stylesTable.getFills().size();
|
|
|
|
|
|
|
|
//setting indexed color
|
|
|
|
cellStyle.setFillBackgroundColor(IndexedColors.RED.getIndex());
|
|
|
|
assertEquals(IndexedColors.RED.getIndex(), cellStyle.getFillBackgroundColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
clr = cellStyle.getFillBackgroundXSSFColor();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertTrue(clr.getCTColor().isSetIndexed());
|
|
|
|
assertEquals(IndexedColors.RED.getIndex(), clr.getIndexed());
|
|
|
|
//a new fill was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getFills().size());
|
|
|
|
|
|
|
|
//id of the created border
|
|
|
|
int fillId = (int)cellStyle.getCoreXf().getFillId();
|
|
|
|
assertTrue(fillId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTFill ctFill = stylesTable.getFillAt(fillId).getCTFill();
|
|
|
|
assertEquals(IndexedColors.RED.getIndex(), ctFill.getPatternFill().getBgColor().getIndexed());
|
|
|
|
|
|
|
|
//setting XSSFColor
|
|
|
|
num = stylesTable.getFills().size();
|
|
|
|
clr = new XSSFColor(java.awt.Color.CYAN);
|
|
|
|
cellStyle.setFillBackgroundColor(clr);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertEquals(clr.getCTColor().toString(), cellStyle.getFillBackgroundXSSFColor().getCTColor().toString());
|
|
|
|
byte[] rgb = cellStyle.getFillBackgroundXSSFColor().getRgb();
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(java.awt.Color.CYAN, new java.awt.Color(rgb[0] & 0xFF, rgb[1] & 0xFF, rgb[2] & 0xFF));
|
|
|
|
//another border was added to the styles table
|
|
|
|
assertEquals(num + 1, stylesTable.getFills().size());
|
|
|
|
|
|
|
|
//passing null unsets the color
|
|
|
|
cellStyle.setFillBackgroundColor(null);
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(cellStyle.getFillBackgroundXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(IndexedColors.AUTOMATIC.getIndex(), cellStyle.getFillBackgroundColor());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
2009-08-18 15:49:28 -04:00
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
public void testDefaultStyles() {
|
|
|
|
|
|
|
|
XSSFWorkbook wb1 = new XSSFWorkbook();
|
|
|
|
|
|
|
|
XSSFCellStyle style1 = wb1.createCellStyle();
|
|
|
|
assertEquals(IndexedColors.AUTOMATIC.getIndex(), style1.getFillBackgroundColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
assertNull(style1.getFillBackgroundXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
|
|
|
|
//compatibility with HSSF
|
|
|
|
HSSFWorkbook wb2 = new HSSFWorkbook();
|
|
|
|
HSSFCellStyle style2 = wb2.createCellStyle();
|
|
|
|
assertEquals(style2.getFillBackgroundColor(), style1.getFillBackgroundColor());
|
|
|
|
assertEquals(style2.getFillForegroundColor(), style1.getFillForegroundColor());
|
|
|
|
assertEquals(style2.getFillPattern(), style1.getFillPattern());
|
|
|
|
|
|
|
|
assertEquals(style2.getLeftBorderColor(), style1.getLeftBorderColor());
|
|
|
|
assertEquals(style2.getTopBorderColor(), style1.getTopBorderColor());
|
|
|
|
assertEquals(style2.getRightBorderColor(), style1.getRightBorderColor());
|
|
|
|
assertEquals(style2.getBottomBorderColor(), style1.getBottomBorderColor());
|
|
|
|
|
|
|
|
assertEquals(style2.getBorderBottom(), style1.getBorderBottom());
|
|
|
|
assertEquals(style2.getBorderLeft(), style1.getBorderLeft());
|
|
|
|
assertEquals(style2.getBorderRight(), style1.getBorderRight());
|
|
|
|
assertEquals(style2.getBorderTop(), style1.getBorderTop());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
2009-08-18 15:49:28 -04:00
|
|
|
|
2008-09-29 00:28:55 -04:00
|
|
|
|
|
|
|
public void testGetFillForegroundColor() {
|
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
XSSFWorkbook wb = new XSSFWorkbook();
|
|
|
|
StylesTable styles = wb.getStylesSource();
|
|
|
|
assertEquals(1, wb.getNumCellStyles());
|
|
|
|
assertEquals(2, styles.getFills().size());
|
2008-09-29 00:28:55 -04:00
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
XSSFCellStyle defaultStyle = wb.getCellStyleAt((short)0);
|
|
|
|
assertEquals(IndexedColors.AUTOMATIC.getIndex(), defaultStyle.getFillForegroundColor());
|
2008-10-29 15:12:47 -04:00
|
|
|
assertEquals(null, defaultStyle.getFillForegroundXSSFColor());
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(CellStyle.NO_FILL, defaultStyle.getFillPattern());
|
2008-09-29 00:28:55 -04:00
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
XSSFCellStyle customStyle = wb.createCellStyle();
|
|
|
|
|
|
|
|
customStyle.setFillPattern(CellStyle.SOLID_FOREGROUND);
|
|
|
|
assertEquals(CellStyle.SOLID_FOREGROUND, customStyle.getFillPattern());
|
|
|
|
assertEquals(3, styles.getFills().size());
|
|
|
|
|
|
|
|
customStyle.setFillForegroundColor(IndexedColors.BRIGHT_GREEN.getIndex());
|
|
|
|
assertEquals(IndexedColors.BRIGHT_GREEN.getIndex(), customStyle.getFillForegroundColor());
|
|
|
|
assertEquals(4, styles.getFills().size());
|
2008-09-29 00:28:55 -04:00
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
XSSFCellStyle style = wb.createCellStyle();
|
2008-09-29 00:28:55 -04:00
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
style.setFillPattern(CellStyle.SOLID_FOREGROUND);
|
|
|
|
assertEquals(CellStyle.SOLID_FOREGROUND, style.getFillPattern());
|
|
|
|
assertEquals(4, styles.getFills().size());
|
2008-09-29 00:28:55 -04:00
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
style.setFillForegroundColor(IndexedColors.BRIGHT_GREEN.getIndex());
|
|
|
|
assertEquals(IndexedColors.BRIGHT_GREEN.getIndex(), style.getFillForegroundColor());
|
|
|
|
assertEquals(4, styles.getFills().size());
|
|
|
|
}
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
2009-08-18 15:49:28 -04:00
|
|
|
|
2008-09-29 00:28:55 -04:00
|
|
|
public void testGetFillPattern() {
|
|
|
|
|
2008-10-05 09:56:28 -04:00
|
|
|
assertEquals(CellStyle.NO_FILL, cellStyle.getFillPattern());
|
|
|
|
|
|
|
|
int num = stylesTable.getFills().size();
|
|
|
|
cellStyle.setFillPattern(CellStyle.SOLID_FOREGROUND);
|
|
|
|
assertEquals(CellStyle.SOLID_FOREGROUND, cellStyle.getFillPattern());
|
|
|
|
assertEquals(num + 1, stylesTable.getFills().size());
|
|
|
|
int fillId = (int)cellStyle.getCoreXf().getFillId();
|
|
|
|
assertTrue(fillId > 0);
|
|
|
|
//check changes in the underlying xml bean
|
|
|
|
CTFill ctFill = stylesTable.getFillAt(fillId).getCTFill();
|
|
|
|
assertEquals(STPatternType.SOLID, ctFill.getPatternFill().getPatternType());
|
|
|
|
|
|
|
|
//setting the same fill multiple time does not update the styles table
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
cellStyle.setFillPattern(CellStyle.SOLID_FOREGROUND);
|
|
|
|
}
|
|
|
|
assertEquals(num + 1, stylesTable.getFills().size());
|
|
|
|
|
|
|
|
cellStyle.setFillPattern(CellStyle.NO_FILL);
|
|
|
|
assertEquals(CellStyle.NO_FILL, cellStyle.getFillPattern());
|
|
|
|
fillId = (int)cellStyle.getCoreXf().getFillId();
|
|
|
|
ctFill = stylesTable.getFillAt(fillId).getCTFill();
|
|
|
|
assertFalse(ctFill.getPatternFill().isSetPatternType());
|
|
|
|
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetFont() {
|
|
|
|
assertNotNull(cellStyle.getFont());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetHidden() {
|
|
|
|
assertFalse(cellStyle.getHidden());
|
2011-06-24 09:06:04 -04:00
|
|
|
cellStyle.setHidden(true);
|
2008-09-29 00:28:55 -04:00
|
|
|
assertTrue(cellStyle.getHidden());
|
|
|
|
cellStyle.setHidden(false);
|
|
|
|
assertFalse(cellStyle.getHidden());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetLocked() {
|
2011-06-24 09:06:04 -04:00
|
|
|
assertTrue(cellStyle.getLocked());
|
|
|
|
cellStyle.setLocked(true);
|
2008-09-29 00:28:55 -04:00
|
|
|
assertTrue(cellStyle.getLocked());
|
|
|
|
cellStyle.setLocked(false);
|
|
|
|
assertFalse(cellStyle.getLocked());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetIndent() {
|
|
|
|
assertEquals((short)0, cellStyle.getIndention());
|
2008-10-21 13:56:34 -04:00
|
|
|
cellStyle.setIndention((short)3);
|
2008-09-29 00:28:55 -04:00
|
|
|
assertEquals((short)3, cellStyle.getIndention());
|
|
|
|
cellStyle.setIndention((short) 13);
|
2008-10-21 13:56:34 -04:00
|
|
|
assertEquals((short)13, cellStyle.getIndention());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetAlignement() {
|
|
|
|
assertNull(cellStyle.getCellAlignment().getCTCellAlignment().getHorizontal());
|
|
|
|
assertEquals(HorizontalAlignment.GENERAL, cellStyle.getAlignmentEnum());
|
|
|
|
|
|
|
|
cellStyle.setAlignment(XSSFCellStyle.ALIGN_LEFT);
|
|
|
|
assertEquals(XSSFCellStyle.ALIGN_LEFT, cellStyle.getAlignment());
|
|
|
|
assertEquals(HorizontalAlignment.LEFT, cellStyle.getAlignmentEnum());
|
|
|
|
assertEquals(STHorizontalAlignment.LEFT, cellStyle.getCellAlignment().getCTCellAlignment().getHorizontal());
|
|
|
|
|
|
|
|
cellStyle.setAlignment(HorizontalAlignment.JUSTIFY);
|
|
|
|
assertEquals(XSSFCellStyle.ALIGN_JUSTIFY, cellStyle.getAlignment());
|
|
|
|
assertEquals(HorizontalAlignment.JUSTIFY, cellStyle.getAlignmentEnum());
|
|
|
|
assertEquals(STHorizontalAlignment.JUSTIFY, cellStyle.getCellAlignment().getCTCellAlignment().getHorizontal());
|
|
|
|
|
|
|
|
cellStyle.setAlignment(HorizontalAlignment.CENTER);
|
|
|
|
assertEquals(XSSFCellStyle.ALIGN_CENTER, cellStyle.getAlignment());
|
|
|
|
assertEquals(HorizontalAlignment.CENTER, cellStyle.getAlignmentEnum());
|
|
|
|
assertEquals(STHorizontalAlignment.CENTER, cellStyle.getCellAlignment().getCTCellAlignment().getHorizontal());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetVerticalAlignment() {
|
|
|
|
assertEquals(VerticalAlignment.BOTTOM, cellStyle.getVerticalAlignmentEnum());
|
|
|
|
assertEquals(XSSFCellStyle.VERTICAL_BOTTOM, cellStyle.getVerticalAlignment());
|
|
|
|
assertNull(cellStyle.getCellAlignment().getCTCellAlignment().getVertical());
|
|
|
|
|
|
|
|
cellStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_CENTER);
|
|
|
|
assertEquals(XSSFCellStyle.VERTICAL_CENTER, cellStyle.getVerticalAlignment());
|
|
|
|
assertEquals(VerticalAlignment.CENTER, cellStyle.getVerticalAlignmentEnum());
|
|
|
|
assertEquals(STVerticalAlignment.CENTER, cellStyle.getCellAlignment().getCTCellAlignment().getVertical());
|
|
|
|
|
|
|
|
cellStyle.setVerticalAlignment(XSSFCellStyle.VERTICAL_JUSTIFY);
|
|
|
|
assertEquals(XSSFCellStyle.VERTICAL_JUSTIFY, cellStyle.getVerticalAlignment());
|
|
|
|
assertEquals(VerticalAlignment.JUSTIFY, cellStyle.getVerticalAlignmentEnum());
|
|
|
|
assertEquals(STVerticalAlignment.JUSTIFY, cellStyle.getCellAlignment().getCTCellAlignment().getVertical());
|
|
|
|
}
|
|
|
|
|
|
|
|
public void testGetSetWrapText() {
|
|
|
|
assertFalse(cellStyle.getWrapText());
|
2008-10-21 13:56:34 -04:00
|
|
|
cellStyle.setWrapText(true);
|
2008-09-29 00:28:55 -04:00
|
|
|
assertTrue(cellStyle.getWrapText());
|
|
|
|
cellStyle.setWrapText(false);
|
2008-10-21 13:56:34 -04:00
|
|
|
assertFalse(cellStyle.getWrapText());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Cloning one XSSFCellStyle onto Another, same XSSFWorkbook
|
|
|
|
*/
|
2009-08-18 15:49:28 -04:00
|
|
|
public void testCloneStyleSameWB() {
|
2010-09-20 16:10:14 -04:00
|
|
|
XSSFWorkbook wb = new XSSFWorkbook();
|
|
|
|
assertEquals(1, wb.getNumberOfFonts());
|
|
|
|
|
|
|
|
XSSFFont fnt = wb.createFont();
|
|
|
|
fnt.setFontName("TestingFont");
|
|
|
|
assertEquals(2, wb.getNumberOfFonts());
|
|
|
|
|
|
|
|
XSSFCellStyle orig = wb.createCellStyle();
|
|
|
|
orig.setAlignment(HSSFCellStyle.ALIGN_RIGHT);
|
|
|
|
orig.setFont(fnt);
|
|
|
|
orig.setDataFormat((short)18);
|
|
|
|
|
|
|
|
assertTrue(HSSFCellStyle.ALIGN_RIGHT == orig.getAlignment());
|
|
|
|
assertTrue(fnt == orig.getFont());
|
|
|
|
assertTrue(18 == orig.getDataFormat());
|
|
|
|
|
|
|
|
XSSFCellStyle clone = wb.createCellStyle();
|
|
|
|
assertFalse(HSSFCellStyle.ALIGN_RIGHT == clone.getAlignment());
|
|
|
|
assertFalse(fnt == clone.getFont());
|
|
|
|
assertFalse(18 == clone.getDataFormat());
|
|
|
|
|
|
|
|
clone.cloneStyleFrom(orig);
|
|
|
|
assertTrue(HSSFCellStyle.ALIGN_RIGHT == clone.getAlignment());
|
|
|
|
assertTrue(fnt == clone.getFont());
|
|
|
|
assertTrue(18 == clone.getDataFormat());
|
|
|
|
assertEquals(2, wb.getNumberOfFonts());
|
2008-09-29 00:28:55 -04:00
|
|
|
}
|
|
|
|
/**
|
|
|
|
* Cloning one XSSFCellStyle onto Another, different XSSFWorkbooks
|
|
|
|
*/
|
2009-08-18 15:49:28 -04:00
|
|
|
public void testCloneStyleDiffWB() {
|
2010-09-20 16:10:14 -04:00
|
|
|
XSSFWorkbook wbOrig = new XSSFWorkbook();
|
|
|
|
assertEquals(1, wbOrig.getNumberOfFonts());
|
|
|
|
assertEquals(0, wbOrig.getStylesSource().getNumberFormats().size());
|
|
|
|
|
|
|
|
XSSFFont fnt = wbOrig.createFont();
|
|
|
|
fnt.setFontName("TestingFont");
|
|
|
|
assertEquals(2, wbOrig.getNumberOfFonts());
|
|
|
|
assertEquals(0, wbOrig.getStylesSource().getNumberFormats().size());
|
|
|
|
|
|
|
|
XSSFDataFormat fmt = wbOrig.createDataFormat();
|
|
|
|
fmt.getFormat("MadeUpOne");
|
|
|
|
fmt.getFormat("MadeUpTwo");
|
|
|
|
|
|
|
|
XSSFCellStyle orig = wbOrig.createCellStyle();
|
|
|
|
orig.setAlignment(HSSFCellStyle.ALIGN_RIGHT);
|
|
|
|
orig.setFont(fnt);
|
|
|
|
orig.setDataFormat(fmt.getFormat("Test##"));
|
|
|
|
|
|
|
|
assertTrue(XSSFCellStyle.ALIGN_RIGHT == orig.getAlignment());
|
|
|
|
assertTrue(fnt == orig.getFont());
|
|
|
|
assertTrue(fmt.getFormat("Test##") == orig.getDataFormat());
|
|
|
|
|
|
|
|
assertEquals(2, wbOrig.getNumberOfFonts());
|
|
|
|
assertEquals(3, wbOrig.getStylesSource().getNumberFormats().size());
|
|
|
|
|
|
|
|
|
|
|
|
// Now a style on another workbook
|
|
|
|
XSSFWorkbook wbClone = new XSSFWorkbook();
|
|
|
|
assertEquals(1, wbClone.getNumberOfFonts());
|
|
|
|
assertEquals(0, wbClone.getStylesSource().getNumberFormats().size());
|
2011-04-21 09:22:18 -04:00
|
|
|
assertEquals(1, wbClone.getNumCellStyles());
|
2010-09-20 16:10:14 -04:00
|
|
|
|
|
|
|
XSSFDataFormat fmtClone = wbClone.createDataFormat();
|
|
|
|
XSSFCellStyle clone = wbClone.createCellStyle();
|
|
|
|
|
|
|
|
assertEquals(1, wbClone.getNumberOfFonts());
|
|
|
|
assertEquals(0, wbClone.getStylesSource().getNumberFormats().size());
|
|
|
|
|
|
|
|
assertFalse(HSSFCellStyle.ALIGN_RIGHT == clone.getAlignment());
|
|
|
|
assertFalse("TestingFont" == clone.getFont().getFontName());
|
|
|
|
|
|
|
|
clone.cloneStyleFrom(orig);
|
|
|
|
|
|
|
|
assertEquals(2, wbClone.getNumberOfFonts());
|
2011-04-21 09:22:18 -04:00
|
|
|
assertEquals(2, wbClone.getNumCellStyles());
|
2010-09-20 16:10:14 -04:00
|
|
|
assertEquals(1, wbClone.getStylesSource().getNumberFormats().size());
|
|
|
|
|
|
|
|
assertEquals(HSSFCellStyle.ALIGN_RIGHT, clone.getAlignment());
|
|
|
|
assertEquals("TestingFont", clone.getFont().getFontName());
|
|
|
|
assertEquals(fmtClone.getFormat("Test##"), clone.getDataFormat());
|
|
|
|
assertFalse(fmtClone.getFormat("Test##") == fmt.getFormat("Test##"));
|
2011-04-21 09:22:18 -04:00
|
|
|
|
|
|
|
// Save it and re-check
|
|
|
|
XSSFWorkbook wbReload = XSSFTestDataSamples.writeOutAndReadBack(wbClone);
|
|
|
|
assertEquals(2, wbReload.getNumberOfFonts());
|
|
|
|
assertEquals(2, wbReload.getNumCellStyles());
|
|
|
|
assertEquals(1, wbReload.getStylesSource().getNumberFormats().size());
|
|
|
|
|
|
|
|
XSSFCellStyle reload = wbReload.getCellStyleAt((short)1);
|
|
|
|
assertEquals(HSSFCellStyle.ALIGN_RIGHT, reload.getAlignment());
|
|
|
|
assertEquals("TestingFont", reload.getFont().getFontName());
|
|
|
|
assertEquals(fmtClone.getFormat("Test##"), reload.getDataFormat());
|
|
|
|
assertFalse(fmtClone.getFormat("Test##") == fmt.getFormat("Test##"));
|
2010-09-20 16:10:14 -04:00
|
|
|
}
|
2011-12-19 04:06:10 -05:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Avoid ArrayIndexOutOfBoundsException when creating cell style
|
|
|
|
* in a workbook that has an empty xf table.
|
|
|
|
*/
|
|
|
|
public void testBug52348() {
|
|
|
|
XSSFWorkbook workbook = XSSFTestDataSamples.openSampleWorkbook("52348.xlsx");
|
|
|
|
StylesTable st = workbook.getStylesSource();
|
|
|
|
assertEquals(0, st._getStyleXfsSize());
|
|
|
|
|
|
|
|
|
|
|
|
XSSFCellStyle style = workbook.createCellStyle(); // no exception at this point
|
|
|
|
assertNull(style.getStyleXf());
|
|
|
|
}
|
|
|
|
|
2008-03-13 07:50:50 -04:00
|
|
|
}
|