import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
+import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.hssf.usermodel.HSSFCell;
/**
public SVTableModel(HSSFSheet st) {
this.st = st;
- Iterator i = st.rowIterator();
+ Iterator<Row> i = st.rowIterator();
while (i.hasNext()) {
HSSFRow row = (HSSFRow)i.next();
return st.getLastRowNum() + 1;
}
- public Class getColumnClass(int c) {
+ public Class<?> getColumnClass(int c) {
return HSSFCell.class;
}
/**
* <p>Maps classes to renderers.</p>
*/
- protected Map renderers;
+ protected Map<Class<?>,TreeCellRenderer> renderers;
public ExtendableTreeCellRenderer()
{
- renderers = new HashMap();
+ renderers = new HashMap<Class<?>,TreeCellRenderer>();
register(Object.class, new DefaultTreeCellRenderer()
{
public Component getTreeCellRendererComponent
- (JTree tree, Object value, boolean selected,
- boolean expanded, boolean leaf, int row, boolean hasFocus)
+ (JTree tree, Object value, boolean selectedCell,
+ boolean expanded, boolean leaf, int row, boolean hasCellFocus)
{
final String s = value.toString();
final JLabel l = new JLabel(s + " ");
/**
* <p>Registers a renderer for a class.</p>
**/
- public void register(final Class c, final TreeCellRenderer renderer)
+ public void register(final Class<?> c, final TreeCellRenderer renderer)
{
renderers.put(c, renderer);
}
* <p>Unregisters a renderer for a class. The renderer for the
* {@link Object} class cannot be unregistered.</p>
*/
- public void unregister(final Class c)
+ public void unregister(final Class<?> c)
{
if (c == Object.class)
throw new IllegalArgumentException
/**
* <p>Find the renderer for the specified class.</p>
*/
- protected TreeCellRenderer findRenderer(final Class c)
+ protected TreeCellRenderer findRenderer(final Class<?> c)
{
- final TreeCellRenderer r = (TreeCellRenderer) renderers.get(c);
+ final TreeCellRenderer r = renderers.get(c);
if (r != null)
/* The class has a renderer. */
return r;
/* The class has no renderer, try the superclass, if any. */
- final Class superclass = c.getSuperclass();
+ final Class<?> superclass = c.getSuperclass();
if (superclass != null) {
return findRenderer(superclass);
}
for (int i = 0; i < args.length; i++)
{
final String filename = args[i];
- try
- {
+ try {
+ FileInputStream fis = new FileInputStream(filename);
POIFSReader r = new POIFSReader();
r.registerListener(new TreeReaderListener(filename, rootNode));
- r.read(new FileInputStream(filename));
+ r.read(fis);
+ fis.close();
displayedFiles++;
- }
- catch (IOException ex)
- {
+ } catch (IOException ex) {
System.err.println(filename + ": " + ex);
- }
- catch (Exception t)
- {
+ } catch (Exception t) {
System.err.println("Unexpected exception while reading \"" +
filename + "\":");
t.printStackTrace(System.err);
public Component getTreeCellRendererComponent(final JTree tree,
final Object value,
- final boolean selected,
+ final boolean selectedCell,
final boolean expanded,
final boolean leaf,
final int row,
- final boolean hasFocus)
+ final boolean hasCellFocus)
{
final PropertySetDescriptor d = (PropertySetDescriptor)
((DefaultMutableTreeNode) value).getUserObject();
text.append("\nSecurity: " + si.getSecurity());
}
- if (selected)
+ if (selectedCell)
Util.invert(text);
return p;
}
* <p>Returns a string representation of a list of {@link
* Section}s.</p>
*/
- protected String sectionsToString(final List sections)
+ protected String sectionsToString(final List<Section> sections)
{
final StringBuffer b = new StringBuffer();
int count = 1;
- for (Iterator i = sections.iterator(); i.hasNext();)
+ for (Iterator<Section> i = sections.iterator(); i.hasNext();)
{
- Section s = (Section) i.next();
+ Section s = i.next();
String d = toString(s, "Section " + count++);
b.append(d);
}
if (recSid == BOFRecord.sid) {
ChartSubstreamRecordAggregate chartAgg = new ChartSubstreamRecordAggregate(rs);
- if (false) {
- // TODO - would like to keep the chart aggregate packed, but one unit test needs attention
- records.add(chartAgg);
- } else {
+// if (false) {
+// // TODO - would like to keep the chart aggregate packed, but one unit test needs attention
+// records.add(chartAgg);
+// } else {
spillAggregate(chartAgg, records);
- }
+// }
continue;
}
@Override
public Object clone() {
- if (false) {
- // TODO - implement clone in a more standardised way
- try {
- return super.clone();
- } catch (CloneNotSupportedException e) {
- throw new RuntimeException(e);
- }
- }
+// if (false) {
+// // TODO - implement clone in a more standardised way
+// try {
+// return super.clone();
+// } catch (CloneNotSupportedException e) {
+// throw new RuntimeException(e);
+// }
+// }
throw new RuntimeException("The class "+getClass().getName()+" needs to define a clone method");
}
@Deprecated
public HSSFFormulaEvaluator(HSSFSheet sheet, HSSFWorkbook workbook) {
this(workbook);
- if (false) {
- sheet.toString(); // suppress unused parameter compiler warning
- }
+// if (false) {
+// sheet.toString(); // suppress unused parameter compiler warning
+// }
this._book = workbook;
}
public HSSFFormulaEvaluator(HSSFWorkbook workbook) {
@Deprecated
public void setCurrentRow(HSSFRow row) {
// do nothing
- if (false) {
- row.getClass(); // suppress unused parameter compiler warning
- }
+// if (false) {
+// row.getClass(); // suppress unused parameter compiler warning
+// }
}
/**
// most colors don't have a second index
continue;
}
- if (result.containsKey(index2)) {
- if (false) { // Many of the second indexes clash
- HSSFColor prevColor = (HSSFColor)result.get(index2);
- throw new RuntimeException("Dup color index (" + index2
- + ") for colors (" + prevColor.getClass().getName()
- + "),(" + color.getClass().getName() + ")");
- }
- }
+// if (result.containsKey(index2)) {
+// if (false) { // Many of the second indexes clash
+// HSSFColor prevColor = (HSSFColor)result.get(index2);
+// throw new RuntimeException("Dup color index (" + index2
+// + ") for colors (" + prevColor.getClass().getName()
+// + "),(" + color.getClass().getName() + ")");
+// }
+// }
result.put(index2, color);
}
return result;
{
// the POIFSReaderListeners who listen to all POIFSReaderEvents
- private Set omnivorousListeners;
+ private Set<POIFSReaderListener> omnivorousListeners;
// Each mapping in this Map has a key consisting of a
// POIFSReaderListener and a value cosisting of a Set of
// DocumentDescriptors for the documents that POIFSReaderListener
// is interested in; used to efficiently manage the registry
- private Map selectiveListeners;
+ private Map<POIFSReaderListener, Set<DocumentDescriptor>> selectiveListeners;
// Each mapping in this Map has a key consisting of a
// DocumentDescriptor and a value consisting of a Set of
// POIFSReaderListeners for the document matching that
// DocumentDescriptor; used when a document is found, to quickly
// get the listeners interested in that document
- private Map chosenDocumentDescriptors;
+ private Map<DocumentDescriptor,Set<POIFSReaderListener>> chosenDocumentDescriptors;
/**
* Construct the registry
POIFSReaderRegistry()
{
- omnivorousListeners = new HashSet();
- selectiveListeners = new HashMap();
- chosenDocumentDescriptors = new HashMap();
+ omnivorousListeners = new HashSet<POIFSReaderListener>();
+ selectiveListeners = new HashMap<POIFSReaderListener, Set<DocumentDescriptor>>();
+ chosenDocumentDescriptors = new HashMap<DocumentDescriptor,Set<POIFSReaderListener>>();
}
/**
// not an omnivorous listener (if it was, this method is a
// no-op)
- Set descriptors = ( Set ) selectiveListeners.get(listener);
+ Set<DocumentDescriptor> descriptors = selectiveListeners.get(listener);
if (descriptors == null)
{
// this listener has not registered before
- descriptors = new HashSet();
+ descriptors = new HashSet<DocumentDescriptor>();
selectiveListeners.put(listener, descriptors);
}
DocumentDescriptor descriptor = new DocumentDescriptor(path,
// this listener wasn't already listening for this
// document -- add the listener to the set of
// listeners for this document
- Set listeners =
- ( Set ) chosenDocumentDescriptors.get(descriptor);
+ Set<POIFSReaderListener> listeners =
+ chosenDocumentDescriptors.get(descriptor);
if (listeners == null)
{
// nobody was listening for this document before
- listeners = new HashSet();
+ listeners = new HashSet<POIFSReaderListener>();
chosenDocumentDescriptors.put(descriptor, listeners);
}
listeners.add(listener);
* @return an Iterator POIFSReaderListeners; may be empty
*/
- Iterator getListeners(final POIFSDocumentPath path, final String name)
+ Iterator<POIFSReaderListener> getListeners(final POIFSDocumentPath path, final String name)
{
- Set rval = new HashSet(omnivorousListeners);
- Set selectiveListeners =
- ( Set ) chosenDocumentDescriptors.get(new DocumentDescriptor(path,
- name));
+ Set<POIFSReaderListener> rval = new HashSet<POIFSReaderListener>(omnivorousListeners);
+ Set<POIFSReaderListener> selectiveListenersInner =
+ chosenDocumentDescriptors.get(new DocumentDescriptor(path, name));
- if (selectiveListeners != null)
+ if (selectiveListenersInner != null)
{
- rval.addAll(selectiveListeners);
+ rval.addAll(selectiveListenersInner);
}
return rval.iterator();
}
private void removeSelectiveListener(final POIFSReaderListener listener)
{
- Set selectedDescriptors = ( Set ) selectiveListeners.remove(listener);
+ Set<DocumentDescriptor> selectedDescriptors = selectiveListeners.remove(listener);
if (selectedDescriptors != null)
{
- Iterator iter = selectedDescriptors.iterator();
+ Iterator<DocumentDescriptor> iter = selectedDescriptors.iterator();
while (iter.hasNext())
{
- dropDocument(listener, ( DocumentDescriptor ) iter.next());
+ dropDocument(listener, iter.next());
}
}
}
private void dropDocument(final POIFSReaderListener listener,
final DocumentDescriptor descriptor)
{
- Set listeners = ( Set ) chosenDocumentDescriptors.get(descriptor);
+ Set<POIFSReaderListener> listeners = chosenDocumentDescriptors.get(descriptor);
listeners.remove(listener);
if (listeners.size() == 0)
* @author Yegor Kozlov
*/
public class ExpressionParser {
- static final HashMap<String, Class> impls = new HashMap<String, Class>();
+ static final HashMap<String, Class<? extends Expression>> impls =
+ new HashMap<String, Class<? extends Expression>>();
+
static {
impls.put("\\*/ +([\\-\\w]+) +([\\-\\w]+) +([\\-\\w]+)", MultiplyDivideExpression.class);
impls.put("\\+- +([\\-\\w]+) +([\\-\\w]+) +([\\-\\w]+)( 0)?", AddSubtractExpression.class);
Pattern ptrn = Pattern.compile(regexp);
Matcher m = ptrn.matcher(str);
if(m.matches()) {
- Class c = impls.get(regexp);
+ Class<? extends Expression> c = impls.get(regexp);
try {
- return (Expression)c.getDeclaredConstructor(Matcher.class).newInstance(m);
+ return c.getDeclaredConstructor(Matcher.class).newInstance(m);
} catch (Exception e){
throw new RuntimeException(e);
}
private Formula(byte[] byteEncoding, int encodedTokenLen) {
_byteEncoding = byteEncoding;
_encodedTokenLen = encodedTokenLen;
- if (false) { // set to true to eagerly check Ptg decoding
- LittleEndianByteArrayInputStream in = new LittleEndianByteArrayInputStream(byteEncoding);
- Ptg.readTokens(encodedTokenLen, in);
- int nUnusedBytes = _byteEncoding.length - in.getReadIndex();
- if (nUnusedBytes > 0) {
- // TODO - this seems to occur when IntersectionPtg is present
- // This example file "IntersectionPtg.xls"
- // used by test: TestIntersectionPtg.testReading()
- // has 10 bytes unused at the end of the formula
- // 10 extra bytes are just 0x01 and 0x00
- System.out.println(nUnusedBytes + " unused bytes at end of formula");
- }
- }
+// if (false) { // set to true to eagerly check Ptg decoding
+// LittleEndianByteArrayInputStream in = new LittleEndianByteArrayInputStream(byteEncoding);
+// Ptg.readTokens(encodedTokenLen, in);
+// int nUnusedBytes = _byteEncoding.length - in.getReadIndex();
+// if (nUnusedBytes > 0) {
+// // TODO - this seems to occur when IntersectionPtg is present
+// // This example file "IntersectionPtg.xls"
+// // used by test: TestIntersectionPtg.testReading()
+// // has 10 bytes unused at the end of the formula
+// // 10 extra bytes are just 0x01 and 0x00
+// System.out.println(nUnusedBytes + " unused bytes at end of formula");
+// }
+// }
}
/**
* Convenience method for {@link #read(int, LittleEndianInput, int)}
private static ValueEval chooseSingleElementFromAreaInternal(AreaEval ae,
int srcCellRow, int srcCellCol) throws EvaluationException {
- if(false) {
- // this is too simplistic
- if(ae.containsRow(srcCellRow) && ae.containsColumn(srcCellCol)) {
- throw new EvaluationException(ErrorEval.CIRCULAR_REF_ERROR);
- }
- /*
- Circular references are not dealt with directly here, but it is worth noting some issues.
-
- ANY one of the return statements in this method could return a cell that is identical
- to the one immediately being evaluated. The evaluating cell is identified by srcCellRow,
- srcCellRow AND sheet. The sheet is not available in any nearby calling method, so that's
- one reason why circular references are not easy to detect here. (The sheet of the returned
- cell can be obtained from ae if it is an Area3DEval.)
-
- Another reason there's little value in attempting to detect circular references here is
- that only direct circular references could be detected. If the cycle involved two or more
- cells this method could not detect it.
-
- Logic to detect evaluation cycles of all kinds has been coded in EvaluationCycleDetector
- (and FormulaEvaluator).
- */
- }
+// if(false) {
+// // this is too simplistic
+// if(ae.containsRow(srcCellRow) && ae.containsColumn(srcCellCol)) {
+// throw new EvaluationException(ErrorEval.CIRCULAR_REF_ERROR);
+// }
+// /*
+// Circular references are not dealt with directly here, but it is worth noting some issues.
+//
+// ANY one of the return statements in this method could return a cell that is identical
+// to the one immediately being evaluated. The evaluating cell is identified by srcCellRow,
+// srcCellRow AND sheet. The sheet is not available in any nearby calling method, so that's
+// one reason why circular references are not easy to detect here. (The sheet of the returned
+// cell can be obtained from ae if it is an Area3DEval.)
+//
+// Another reason there's little value in attempting to detect circular references here is
+// that only direct circular references could be detected. If the cycle involved two or more
+// cells this method could not detect it.
+//
+// Logic to detect evaluation cycles of all kinds has been coded in EvaluationCycleDetector
+// (and FormulaEvaluator).
+// */
+// }
if (ae.isColumn()) {
if(ae.isRow()) {
package org.apache.poi.openxml4j.opc;
+import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.util.TreeMap;
import org.apache.poi.openxml4j.opc.internal.FileHelper;
-
-import junit.framework.TestCase;
+import org.junit.Test;
/**
* Test TestFileHelper class.
*
* @author Julien Chable
*/
-public final class TestFileHelper extends TestCase {
+public final class TestFileHelper {
/**
* TODO - use simple JDK methods on {@link File} instead:<br/>
* {@link File#getParentFile()} instead of {@link FileHelper#getDirectory(File)
* {@link File#getName()} instead of {@link FileHelper#getFilename(File)
*/
+ @Test
public void testGetDirectory() {
TreeMap<String, String> expectedValue = new TreeMap<String, String>();
expectedValue.put("/dir1/test.doc", "/dir1");
File f1 = new File(expectedValue.get(filename));
File f2 = FileHelper.getDirectory(new File(filename));
- if (false) {
- // YK: The original version asserted expected values against File#getAbsolutePath():
- assertTrue(expectedValue.get(filename).equalsIgnoreCase(f2.getAbsolutePath()));
- // This comparison is platform dependent. A better approach is below
- }
+// if (false) {
+// // YK: The original version asserted expected values against File#getAbsolutePath():
+// assertTrue(expectedValue.get(filename).equalsIgnoreCase(f2.getAbsolutePath()));
+// // This comparison is platform dependent. A better approach is below
+// }
assertTrue(f1.equals(f2));
}
}
==================================================================== */\r
package org.apache.poi.xssf.streaming;\r
\r
+import static org.junit.Assert.assertEquals;\r
+\r
import java.util.List;\r
\r
import org.apache.poi.ss.usermodel.BaseTestDataValidation;\r
import org.apache.poi.ss.usermodel.Sheet;\r
import org.apache.poi.ss.util.CellRangeAddressList;\r
import org.apache.poi.xssf.SXSSFITestDataProvider;\r
+import org.junit.Test;\r
\r
public class TestSXSSFDataValidation extends BaseTestDataValidation {\r
\r
super(SXSSFITestDataProvider.instance);\r
}\r
\r
+ @Test\r
public void test53965() throws Exception {\r
SXSSFWorkbook wb = new SXSSFWorkbook();\r
try {\r
==================================================================== */
package org.apache.poi.xssf.usermodel;
+import static org.junit.Assert.assertEquals;
+
import java.io.IOException;
import java.math.BigDecimal;
import java.util.List;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.xssf.XSSFITestDataProvider;
import org.apache.poi.xssf.XSSFTestDataSamples;
+import org.junit.Test;
public class TestXSSFDataValidation extends BaseTestDataValidation {
super(XSSFITestDataProvider.instance);
}
+ @Test
public void testAddValidations() throws Exception {
- XSSFWorkbook workbook = XSSFTestDataSamples.openSampleWorkbook("DataValidations-49244.xlsx");
- Sheet sheet = workbook.getSheetAt(0);
+ XSSFWorkbook wb1 = XSSFTestDataSamples.openSampleWorkbook("DataValidations-49244.xlsx");
+ Sheet sheet = wb1.getSheetAt(0);
List<XSSFDataValidation> dataValidations = ((XSSFSheet)sheet).getDataValidations();
/**
}
}
- workbook = XSSFTestDataSamples.writeOutAndReadBack(workbook);
- Sheet sheetAt = workbook.getSheetAt(0);
+ XSSFWorkbook wb2 = XSSFTestDataSamples.writeOutAndReadBack(wb1);
+ wb1.close();
+ Sheet sheetAt = wb2.getSheetAt(0);
assertEquals(lastKnownNumValidations,((XSSFSheet)sheetAt).getDataValidations().size());
+ wb2.close();
}
protected void setOtherValidationParameters(DataValidation validation) {
validation.setSuppressDropDownArrow(yesNo);
}
+ @Test
public void test53965() throws Exception {
XSSFWorkbook wb = new XSSFWorkbook();
try {
}
}
+ @Test
public void testDefaultAllowBlank() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
}
}
+ @Test
public void testSetAllowBlankToFalse() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
}
}
+ @Test
public void testSetAllowBlankToTrue() throws IOException {
XSSFWorkbook wb = new XSSFWorkbook();
try {
package org.apache.poi.xssf.usermodel;
import org.apache.poi.xssf.XSSFTestDataSamples;
+import org.junit.Test;
import org.apache.poi.xssf.XSSFITestDataProvider;
+
+import static org.junit.Assert.*;
+
import org.apache.poi.ss.usermodel.BaseTestNamedRange;
import org.apache.poi.ss.util.CellRangeAddress;
}
//TODO combine testRepeatingRowsAndColums() for HSSF and XSSF
- public void testRepeatingRowsAndColums() {
+ @Test
+ public void testRepeatingRowsAndColums() throws Exception {
// First test that setting RR&C for same sheet more than once only creates a
// single Print_Titles built-in record
XSSFWorkbook wb = new XSSFWorkbook();
// Save and re-open
XSSFWorkbook nwb = XSSFTestDataSamples.writeOutAndReadBack(wb);
-
+ wb.close();
+
assertEquals(1, nwb.getNumberOfNames());
nr1 = nwb.getNameAt(0);
sheet2.setRepeatingRows(null);
sheet2.setRepeatingColumns(null);
+ nwb.close();
}
}
String rHexType = reverseHex(hexType);
// Grab the hslf.record type
- Class c = r.getClass();
+ Class<? extends Record> c = r.getClass();
String cname = c.toString();
if(cname.startsWith("class ")) {
cname = cname.substring(6);
package org.apache.poi.hssf.eventusermodel;
-import junit.framework.Test;
-import junit.framework.TestSuite;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
* Collects all tests for <tt>org.apache.poi.hssf.eventusermodel</tt>.
- *
- * @author Josh Micich
*/
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TestEventWorkbookBuilder.class,
+ TestFormatTrackingHSSFListener.class,
+ TestHSSFEventFactory.class,
+ TestMissingRecordAwareHSSFListener.class
+})
public class AllEventUserModelTests {
-
- public static Test suite() {
- TestSuite result = new TestSuite(AllEventUserModelTests.class.getName());
- result.addTestSuite(TestEventWorkbookBuilder.class);
- result.addTestSuite(TestFormatTrackingHSSFListener.class);
- result.addTestSuite(TestHSSFEventFactory.class);
- result.addTestSuite(TestMissingRecordAwareHSSFListener.class);
- return result;
- }
}
==================================================================== */
package org.apache.poi.hssf.eventusermodel;
-import java.io.IOException;
-import java.io.InputStream;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
import java.util.ArrayList;
import java.util.List;
-import junit.framework.TestCase;
-
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.record.CellValueRecordInterface;
import org.apache.poi.hssf.record.FormulaRecord;
import org.apache.poi.hssf.record.NumberRecord;
import org.apache.poi.hssf.record.Record;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
+import org.junit.Test;
/**
* Tests for FormatTrackingHSSFListener
*/
-public final class TestFormatTrackingHSSFListener extends TestCase {
+public final class TestFormatTrackingHSSFListener {
private FormatTrackingHSSFListener listener;
private MockHSSFListener mockListen;
listener = new FormatTrackingHSSFListener(mockListen);
req.addListenerForAllRecords(listener);
+ File file = HSSFTestDataSamples.getSampleFile(filename);
HSSFEventFactory factory = new HSSFEventFactory();
- try {
- InputStream is = HSSFTestDataSamples.openSampleFileStream(filename);
- POIFSFileSystem fs = new POIFSFileSystem(is);
- factory.processWorkbookEvents(req, fs);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
+ POIFSFileSystem fs = new POIFSFileSystem(file);
+ factory.processWorkbookEvents(req, fs);
+ fs.close();
}
+ @Test
public void testFormats() throws Exception {
processFile("MissingBits.xls");
* exceptions thrown, but in future we might also
* want to check the exact strings!
*/
+ @Test
public void testTurnToString() throws Exception {
String[] files = new String[] {
"45365.xls", "45365-2.xls", "MissingBits.xls"
// Now check we can turn all the numeric
// cells into strings without error
- for(int i=0; i<mockListen._records.size(); i++) {
- Record r = (Record)mockListen._records.get(i);
+ for(Record r : mockListen._records) {
CellValueRecordInterface cvr = null;
if(r instanceof NumberRecord) {
private static final class MockHSSFListener implements HSSFListener {
public MockHSSFListener() {}
- private final List _records = new ArrayList();
+ private final List<Record> _records = new ArrayList<Record>();
public void processRecord(Record record) {
_records.add(record);
package org.apache.poi.hssf.record;
+import static org.junit.Assert.assertEquals;
+
import java.io.IOException;
import java.io.InputStream;
-import junit.framework.TestCase;
-
import org.apache.poi.hssf.HSSFTestDataSamples;
+import org.apache.poi.hssf.record.common.UnicodeString;
import org.apache.poi.util.HexRead;
import org.apache.poi.util.IntMapper;
+import org.junit.Test;
/**
* Exercise the SSTDeserializer class.
*
* @author Glen Stampoultzis (glens at apache.org)
*/
-public final class TestSSTDeserializer extends TestCase {
+public final class TestSSTDeserializer {
private static final int FAKE_SID = -5555;
private static byte[] concat(byte[] a, byte[] b) {
return result;
}
- private static byte[] readSampleHexData(String sampleFileName, String sectionName, int recSid) {
+ private static byte[] readSampleHexData(String sampleFileName, String sectionName, int recSid)
+ throws IOException {
InputStream is = HSSFTestDataSamples.openSampleFileStream(sampleFileName);
- byte[] data;
- try {
- data = HexRead.readData(is, sectionName);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- return TestcaseRecordInputStream.mergeDataAndSid(recSid, data.length, data);
+ byte[] data = HexRead.readData(is, sectionName);
+ byte[] result = TestcaseRecordInputStream.mergeDataAndSid(recSid, data.length, data);
+ is.close();
+ return result;
}
- public void testSpanRichTextToPlainText() {
+ @Test
+ public void testSpanRichTextToPlainText() throws IOException {
byte[] header = readSampleHexData("richtextdata.txt", "header", FAKE_SID);
byte[] continueBytes = readSampleHexData("richtextdata.txt", "continue1", ContinueRecord.sid);
RecordInputStream in = TestcaseRecordInputStream.create(concat(header, continueBytes));
- IntMapper strings = new IntMapper();
+ IntMapper<UnicodeString> strings = new IntMapper<UnicodeString>();
SSTDeserializer deserializer = new SSTDeserializer( strings );
deserializer.manufactureStrings(1, in );
assertEquals( "At a dinner party orAt At At ", strings.get( 0 ) + "" );
}
- public void testContinuationWithNoOverlap() {
+ @Test
+ public void testContinuationWithNoOverlap() throws IOException {
byte[] header = readSampleHexData("evencontinuation.txt", "header", FAKE_SID);
byte[] continueBytes = readSampleHexData("evencontinuation.txt", "continue1", ContinueRecord.sid);
RecordInputStream in = TestcaseRecordInputStream.create(concat(header, continueBytes));
- IntMapper strings = new IntMapper();
+ IntMapper<UnicodeString> strings = new IntMapper<UnicodeString>();
SSTDeserializer deserializer = new SSTDeserializer( strings );
deserializer.manufactureStrings( 2, in);
/**
* Strings can actually span across more than one continuation.
*/
- public void testStringAcross2Continuations() {
+ @Test
+ public void testStringAcross2Continuations() throws IOException {
byte[] header = readSampleHexData("stringacross2continuations.txt", "header", FAKE_SID);
byte[] continue1 = readSampleHexData("stringacross2continuations.txt", "continue1", ContinueRecord.sid);
byte[] continue2 = readSampleHexData("stringacross2continuations.txt", "continue2", ContinueRecord.sid);
RecordInputStream in = TestcaseRecordInputStream.create(concat(header, concat(continue1, continue2)));
- IntMapper strings = new IntMapper();
+ IntMapper<UnicodeString> strings = new IntMapper<UnicodeString>();
SSTDeserializer deserializer = new SSTDeserializer( strings );
deserializer.manufactureStrings( 2, in);
assertEquals( "At a dinner partyAt a dinner party", strings.get( 1 ) + "" );
}
- public void testExtendedStrings() {
+ @Test
+ public void testExtendedStrings() throws IOException {
byte[] header = readSampleHexData("extendedtextstrings.txt", "rich-header", FAKE_SID);
byte[] continueBytes = readSampleHexData("extendedtextstrings.txt", "rich-continue1", ContinueRecord.sid);
RecordInputStream in = TestcaseRecordInputStream.create(concat(header, continueBytes));
- IntMapper strings = new IntMapper();
+ IntMapper<UnicodeString> strings = new IntMapper<UnicodeString>();
SSTDeserializer deserializer = new SSTDeserializer( strings );
deserializer.manufactureStrings( 1, in);
continueBytes = readSampleHexData("extendedtextstrings.txt", "norich-continue1", ContinueRecord.sid);
in = TestcaseRecordInputStream.create(concat(header, continueBytes));
- strings = new IntMapper();
+ strings = new IntMapper<UnicodeString>();
deserializer = new SSTDeserializer( strings );
deserializer.manufactureStrings( 1, in);
package org.apache.poi.hssf.record.aggregates;
+import static org.junit.Assert.assertEquals;
+
import java.util.ArrayList;
import java.util.List;
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
-
import org.apache.poi.hssf.record.ColumnInfoRecord;
import org.apache.poi.hssf.record.Record;
import org.apache.poi.hssf.record.RecordBase;
import org.apache.poi.hssf.record.aggregates.RecordAggregate.RecordVisitor;
+import org.junit.Test;
+
+import junit.framework.AssertionFailedError;
-/**
- * @author Glen Stampoultzis
- */
-public final class TestColumnInfoRecordsAggregate extends TestCase {
+public final class TestColumnInfoRecordsAggregate {
- public void testGetRecordSize() {
+ @Test
+ public void testGetRecordSize() {
ColumnInfoRecordsAggregate agg = new ColumnInfoRecordsAggregate();
agg.insertColumn(createColInfo(1, 3));
agg.insertColumn(createColInfo(4, 7));
private static final class CIRCollector implements RecordVisitor {
- private List _list;
- public CIRCollector() {
- _list = new ArrayList();
- }
+ private List<Record> _list = new ArrayList<Record>();
+
public void visitRecord(Record r) {
_list.add(r);
}
+
public static ColumnInfoRecord[] getRecords(ColumnInfoRecordsAggregate agg) {
CIRCollector circ = new CIRCollector();
agg.visitContainedRecords(circ);
- List list = circ._list;
- ColumnInfoRecord[] result = new ColumnInfoRecord[list.size()];
- list.toArray(result);
+ ColumnInfoRecord[] result =
+ circ._list.toArray(new ColumnInfoRecord[circ._list.size()]);
return result;
}
}
+ @Test
public void testGroupColumns_bug45639() {
ColumnInfoRecordsAggregate agg = new ColumnInfoRecordsAggregate();
agg.groupColumnRange( 7, 9, true);
/**
* Check that an inner group remains hidden
*/
+ @Test
public void testHiddenAfterExpanding() {
ColumnInfoRecordsAggregate agg = new ColumnInfoRecordsAggregate();
agg.groupColumnRange(1, 15, true);
confirmCIR(cirs, 2, 13, 15, 1, true, false);
confirmCIR(cirs, 3, 16, 16, 0, false, true);
}
+
private static void confirmCIR(ColumnInfoRecord[] cirs, int ix, int startColIx, int endColIx, int level, boolean isHidden, boolean isCollapsed) {
ColumnInfoRecord cir = cirs[ix];
assertEquals("startColIx", startColIx, cir.getFirstColumn());
package org.apache.poi.hssf.record.chart;
-import junit.framework.Test;
-import junit.framework.TestSuite;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
* Collects all tests for package <tt>org.apache.poi.hssf.record.class</tt>.
- *
- * @author Josh Micich
*/
-public final class AllChartRecordTests {
-
- public static Test suite() {
- TestSuite result = new TestSuite(AllChartRecordTests.class.getName());
-
- result.addTestSuite(TestAreaFormatRecord.class);
- result.addTestSuite(TestAreaRecord.class);
- result.addTestSuite(TestAxisLineFormatRecord.class);
- result.addTestSuite(TestAxisOptionsRecord.class);
- result.addTestSuite(TestAxisParentRecord.class);
- result.addTestSuite(TestAxisRecord.class);
- result.addTestSuite(TestAxisUsedRecord.class);
- result.addTestSuite(TestBarRecord.class);
- result.addTestSuite(TestCategorySeriesAxisRecord.class);
- result.addTestSuite(TestChartFormatRecord.class);
- result.addTestSuite(TestChartRecord.class);
- result.addTestSuite(TestChartTitleFormatRecord.class);
- result.addTestSuite(TestDatRecord.class);
- result.addTestSuite(TestDataFormatRecord.class);
- result.addTestSuite(TestDefaultDataLabelTextPropertiesRecord.class);
- result.addTestSuite(TestFontBasisRecord.class);
- result.addTestSuite(TestFontIndexRecord.class);
- result.addTestSuite(TestFrameRecord.class);
- result.addTestSuite(TestLegendRecord.class);
- result.addTestSuite(TestLineFormatRecord.class);
- result.addTestSuite(TestLinkedDataRecord.class);
- result.addTestSuite(TestNumberFormatIndexRecord.class);
- result.addTestSuite(TestObjectLinkRecord.class);
- result.addTestSuite(TestPlotAreaRecord.class);
- result.addTestSuite(TestPlotGrowthRecord.class);
- result.addTestSuite(TestSeriesChartGroupIndexRecord.class);
- result.addTestSuite(TestSeriesIndexRecord.class);
- result.addTestSuite(TestSeriesLabelsRecord.class);
- result.addTestSuite(TestSeriesListRecord.class);
- result.addTestSuite(TestSeriesRecord.class);
- result.addTestSuite(TestSeriesTextRecord.class);
- result.addTestSuite(TestSeriesToChartGroupRecord.class);
- result.addTestSuite(TestSheetPropertiesRecord.class);
- result.addTestSuite(TestTextRecord.class);
- result.addTestSuite(TestTickRecord.class);
- result.addTestSuite(TestUnitsRecord.class);
- result.addTestSuite(TestValueRangeRecord.class);
- return result;
- }
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TestAreaFormatRecord.class,
+ TestAreaRecord.class,
+ TestAxisLineFormatRecord.class,
+ TestAxisOptionsRecord.class,
+ TestAxisParentRecord.class,
+ TestAxisRecord.class,
+ TestAxisUsedRecord.class,
+ TestBarRecord.class,
+ TestCategorySeriesAxisRecord.class,
+ TestChartFormatRecord.class,
+ TestChartRecord.class,
+ TestChartTitleFormatRecord.class,
+ TestDatRecord.class,
+ TestDataFormatRecord.class,
+ TestDefaultDataLabelTextPropertiesRecord.class,
+ TestFontBasisRecord.class,
+ TestFontIndexRecord.class,
+ TestFrameRecord.class,
+ TestLegendRecord.class,
+ TestLineFormatRecord.class,
+ TestLinkedDataRecord.class,
+ TestNumberFormatIndexRecord.class,
+ TestObjectLinkRecord.class,
+ TestPlotAreaRecord.class,
+ TestPlotGrowthRecord.class,
+ TestSeriesChartGroupIndexRecord.class,
+ TestSeriesIndexRecord.class,
+ TestSeriesLabelsRecord.class,
+ TestSeriesListRecord.class,
+ TestSeriesRecord.class,
+ TestSeriesTextRecord.class,
+ TestSeriesToChartGroupRecord.class,
+ TestSheetPropertiesRecord.class,
+ TestTextRecord.class,
+ TestTickRecord.class,
+ TestUnitsRecord.class,
+ TestValueRangeRecord.class
+})
+public class AllChartRecordTests {
}
package org.apache.poi.hssf.record.chart;
+import static org.junit.Assert.assertEquals;
+
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
-import junit.framework.TestCase;
-
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.eventusermodel.HSSFEventFactory;
import org.apache.poi.hssf.eventusermodel.HSSFListener;
import org.apache.poi.hssf.eventusermodel.HSSFRequest;
import org.apache.poi.hssf.record.Record;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
-import org.apache.poi.poifs.filesystem.POIFSFileSystem;
-/**
- *
- */
-public final class TestChartTitleFormatRecord extends TestCase {
+import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
+import org.junit.Test;
+
+public final class TestChartTitleFormatRecord {
- public void testRecord() throws Exception {
- POIFSFileSystem fs = new POIFSFileSystem(
- HSSFTestDataSamples.openSampleFileStream("WithFormattedGraphTitle.xls"));
+ @Test
+ public void testRecord() throws Exception {
+ NPOIFSFileSystem fs = new NPOIFSFileSystem(
+ HSSFTestDataSamples.getSampleFile("WithFormattedGraphTitle.xls"));
// Check we can open the file via usermodel
HSSFWorkbook hssf = new HSSFWorkbook(fs);
// Should've found one
assertEquals(1, grabber.chartTitleFormatRecords.size());
// And it should be of something interesting
- ChartTitleFormatRecord r =
- (ChartTitleFormatRecord)grabber.chartTitleFormatRecords.get(0);
+ ChartTitleFormatRecord r = grabber.chartTitleFormatRecords.get(0);
assertEquals(3, r.getFormatCount());
+
+ hssf.close();
+ fs.close();
+
}
private static final class ChartTitleFormatRecordGrabber implements HSSFListener {
- private final List chartTitleFormatRecords;
+ private final List<ChartTitleFormatRecord> chartTitleFormatRecords;
public ChartTitleFormatRecordGrabber() {
- chartTitleFormatRecords = new ArrayList();
+ chartTitleFormatRecords = new ArrayList<ChartTitleFormatRecord>();
}
public void processRecord(Record record) {
if(record instanceof ChartTitleFormatRecord) {
- chartTitleFormatRecords.add(
- record
- );
+ chartTitleFormatRecords.add((ChartTitleFormatRecord)record);
}
}
package org.apache.poi.hssf.usermodel;
-import junit.framework.Assert;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+
import org.apache.poi.hssf.model.InternalSheet;
import org.apache.poi.hssf.model.InternalWorkbook;
-import org.apache.poi.hssf.record.*;
+import org.apache.poi.hssf.record.BOFRecord;
+import org.apache.poi.hssf.record.BackupRecord;
+import org.apache.poi.hssf.record.BookBoolRecord;
+import org.apache.poi.hssf.record.BoundSheetRecord;
+import org.apache.poi.hssf.record.CalcModeRecord;
+import org.apache.poi.hssf.record.CodepageRecord;
+import org.apache.poi.hssf.record.CountryRecord;
+import org.apache.poi.hssf.record.DSFRecord;
+import org.apache.poi.hssf.record.DateWindow1904Record;
+import org.apache.poi.hssf.record.DefaultColWidthRecord;
+import org.apache.poi.hssf.record.DefaultRowHeightRecord;
+import org.apache.poi.hssf.record.DeltaRecord;
+import org.apache.poi.hssf.record.DimensionsRecord;
+import org.apache.poi.hssf.record.EOFRecord;
+import org.apache.poi.hssf.record.ExtSSTRecord;
+import org.apache.poi.hssf.record.ExtendedFormatRecord;
+import org.apache.poi.hssf.record.ExternSheetRecord;
+import org.apache.poi.hssf.record.FnGroupCountRecord;
+import org.apache.poi.hssf.record.FontRecord;
+import org.apache.poi.hssf.record.FormatRecord;
+import org.apache.poi.hssf.record.GridsetRecord;
+import org.apache.poi.hssf.record.GutsRecord;
+import org.apache.poi.hssf.record.HideObjRecord;
+import org.apache.poi.hssf.record.InterfaceEndRecord;
+import org.apache.poi.hssf.record.InterfaceHdrRecord;
+import org.apache.poi.hssf.record.IterationRecord;
+import org.apache.poi.hssf.record.MMSRecord;
+import org.apache.poi.hssf.record.NameRecord;
+import org.apache.poi.hssf.record.PasswordRev4Record;
+import org.apache.poi.hssf.record.PrecisionRecord;
+import org.apache.poi.hssf.record.PrintGridlinesRecord;
+import org.apache.poi.hssf.record.PrintHeadersRecord;
+import org.apache.poi.hssf.record.ProtectRecord;
+import org.apache.poi.hssf.record.Record;
+import org.apache.poi.hssf.record.RecordBase;
+import org.apache.poi.hssf.record.RefModeRecord;
+import org.apache.poi.hssf.record.RefreshAllRecord;
+import org.apache.poi.hssf.record.SSTRecord;
+import org.apache.poi.hssf.record.SaveRecalcRecord;
+import org.apache.poi.hssf.record.SelectionRecord;
+import org.apache.poi.hssf.record.StyleRecord;
+import org.apache.poi.hssf.record.SupBookRecord;
+import org.apache.poi.hssf.record.TabIdRecord;
+import org.apache.poi.hssf.record.UseSelFSRecord;
+import org.apache.poi.hssf.record.WSBoolRecord;
+import org.apache.poi.hssf.record.WindowOneRecord;
+import org.apache.poi.hssf.record.WindowProtectRecord;
+import org.apache.poi.hssf.record.WindowTwoRecord;
+import org.apache.poi.hssf.record.WriteAccessRecord;
import org.apache.poi.hssf.record.aggregates.PageSettingsBlock;
-import java.util.List;
-
/**
* Designed to check wither the records written actually make sense.
*/
-public class SanityChecker
- extends Assert
-{
+public class SanityChecker {
static class CheckRecord
{
- Class record;
+ Class<? extends RecordBase> record;
char occurance; // 1 = one time, M = 1..many times, * = 0..many, 0 = optional
private boolean together;
- public CheckRecord( Class record, char occurance )
+ public CheckRecord( Class<? extends RecordBase> record, char occurance )
{
this(record, occurance, true);
}
* @param occurance The occurance 1 = occurs once, M = occurs many times
* @param together
*/
- public CheckRecord(Class record, char occurance, boolean together)
+ public CheckRecord(Class<? extends RecordBase> record, char occurance, boolean together)
{
this.record = record;
this.occurance = occurance;
this.together = together;
}
- public Class getRecord()
+ public Class<? extends RecordBase> getRecord()
{
return record;
}
return occurance == '*' || occurance == 'M';
}
- public int match( List records, int recordIdx )
+ public int match( List<? extends RecordBase> records, int recordIdx )
{
int firstRecord = findFirstRecord(records, getRecord(), recordIdx);
if (isRequired())
return matchOptional( firstRecord, records, recordIdx );
}
- private int matchOptional( int firstRecord, List records, int recordIdx )
+ private int matchOptional( int firstRecord, List<? extends RecordBase> records, int recordIdx )
{
if (firstRecord == -1)
{
return matchOneOrMany( records, firstRecord );
}
- private int matchRequired( int firstRecord, List records, int recordIdx )
+ private int matchRequired( int firstRecord, List<? extends RecordBase> records, int recordIdx )
{
if (firstRecord == -1)
{
return matchOneOrMany( records, firstRecord );
}
- private int matchOneOrMany( List records, int recordIdx )
+ private int matchOneOrMany( List<? extends RecordBase> records, int recordIdx )
{
if (isZeroOrOne())
{
private void checkWorkbookRecords(InternalWorkbook workbook)
{
- List records = workbook.getRecords();
+ List<Record> records = workbook.getRecords();
assertTrue(records.get(0) instanceof BOFRecord);
assertTrue(records.get(records.size() - 1) instanceof EOFRecord);
}
private void checkSheetRecords(InternalSheet sheet) {
- List records = sheet.getRecords();
+ List<RecordBase> records = sheet.getRecords();
assertTrue(records.get(0) instanceof BOFRecord);
assertTrue(records.get(records.size() - 1) instanceof EOFRecord);
}
} */
- /* package */ static int findFirstRecord( List records, Class record, int startIndex )
+ /* package */ static int findFirstRecord( List<? extends RecordBase> records, Class<? extends RecordBase> record, int startIndex )
{
for (int i = startIndex; i < records.size(); i++)
{
return -1;
}
- void checkRecordOrder(List records, CheckRecord[] check)
+ void checkRecordOrder(List<? extends RecordBase> records, CheckRecord[] check)
{
int recordIdx = 0;
for ( int checkIdx = 0; checkIdx < check.length; checkIdx++ )
package org.apache.poi.hssf.usermodel;
-import java.util.Iterator;
+import static org.junit.Assert.assertNotNull;
-import junit.framework.TestCase;
+import java.util.Iterator;
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.record.FormulaRecord;
import org.apache.poi.hssf.record.aggregates.FormulaRecordAggregate;
-import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.hssf.util.CellReference;
+import org.apache.poi.ss.formula.ptg.Ptg;
+import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellValue;
+import org.apache.poi.ss.usermodel.Row;
+import org.junit.Test;
/**
*
*/
-public final class TestBug42464 extends TestCase {
+public final class TestBug42464 {
- public void testOKFile() {
+ @Test
+ public void testOKFile() throws Exception {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("42464-ExpPtg-ok.xls");
process(wb);
+ wb.close();
}
- public void testExpSharedBadFile() {
+
+ @Test
+ public void testExpSharedBadFile() throws Exception {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("42464-ExpPtg-bad.xls");
process(wb);
+ wb.close();
}
private static void process(HSSFWorkbook wb) {
for(int i=0; i<wb.getNumberOfSheets(); i++) {
HSSFSheet s = wb.getSheetAt(i);
- Iterator it = s.rowIterator();
+ Iterator<Row> it = s.rowIterator();
while(it.hasNext()) {
HSSFRow r = (HSSFRow)it.next();
process(r, eval);
}
private static void process(HSSFRow row, HSSFFormulaEvaluator eval) {
- Iterator it = row.cellIterator();
+ Iterator<Cell> it = row.cellIterator();
while(it.hasNext()) {
HSSFCell cell = (HSSFCell)it.next();
if(cell.getCellType() != HSSFCell.CELL_TYPE_FORMULA) {
Ptg[] ptgs = r.getParsedExpression();
String cellRef = new CellReference(row.getRowNum(), cell.getColumnIndex(), false, false).formatAsString();
- if(false && cellRef.equals("BP24")) { // TODO - replace System.out.println()s with asserts
- System.out.print(cellRef);
- System.out.println(" - has " + ptgs.length + " ptgs:");
-
for(int i=0; i<ptgs.length; i++) {
- String c = ptgs[i].getClass().toString();
- System.out.println("\t" + c.substring(c.lastIndexOf('.')+1) );
- }
- System.out.println("-> " + cell.getCellFormula());
- }
+// if(false && cellRef.equals("BP24")) { // TODO - replace System.out.println()s with asserts
+// System.out.print(cellRef);
+// System.out.println(" - has " + ptgs.length + " ptgs:");
+
// for(int i=0; i<ptgs.length; i++) {
+// String c = ptgs[i].getClass().toString();
+// System.out.println("\t" + c.substring(c.lastIndexOf('.')+1) );
+// }
+// System.out.println("-> " + cell.getCellFormula());
+// }
CellValue evalResult = eval.evaluate(cell);
assertNotNull(evalResult);
package org.apache.poi.hssf.usermodel;
-import java.io.ByteArrayInputStream;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
-import java.io.InputStream;
import java.io.PrintStream;
import java.util.List;
-import junit.framework.AssertionFailedError;
-
import org.apache.poi.hssf.HSSFITestDataProvider;
import org.apache.poi.hssf.HSSFTestDataSamples;
-import org.apache.poi.hssf.eventmodel.ERFListener;
-import org.apache.poi.hssf.eventmodel.EventRecordFactory;
import org.apache.poi.hssf.record.DVRecord;
-import org.apache.poi.hssf.record.RecordFormatException;
-import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.BaseTestDataValidation;
import org.apache.poi.ss.usermodel.DataValidation;
+import org.apache.poi.ss.usermodel.DataValidation.ErrorStyle;
import org.apache.poi.ss.usermodel.DataValidationConstraint;
import org.apache.poi.ss.usermodel.DataValidationConstraint.OperatorType;
import org.apache.poi.ss.usermodel.DataValidationConstraint.ValidationType;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
-import org.apache.poi.ss.usermodel.*;
-import org.apache.poi.ss.usermodel.DataValidation.ErrorStyle;
-import org.apache.poi.ss.usermodel.DataValidationConstraint.OperatorType;
import org.apache.poi.ss.util.CellRangeAddressList;
+import org.junit.Test;
/**
* Class for testing Excel's data validation mechanism
}
byte[] generatedContent = baos.toByteArray();
boolean isSame;
- if (false) {
- // TODO - add proof spreadsheet and compare
- InputStream proofStream = HSSFTestDataSamples.openSampleFileStream("TestDataValidation.xls");
- isSame = compareStreams(proofStream, generatedContent);
- }
+// if (false) {
+// // TODO - add proof spreadsheet and compare
+// InputStream proofStream = HSSFTestDataSamples.openSampleFileStream("TestDataValidation.xls");
+// isSame = compareStreams(proofStream, generatedContent);
+// }
isSame = true;
if (isSame) {
}
- private static boolean compareStreams(InputStream isA, byte[] generatedContent) {
-
- InputStream isB = new ByteArrayInputStream(generatedContent);
-
- // The allowable regions where the generated file can differ from the
- // proof should be small (i.e. much less than 1K)
- int[] allowableDifferenceRegions = {
- 0x0228, 16, // a region of the file containing the OS username
- 0x506C, 8, // See RootProperty (super fields _seconds_2 and _days_2)
- };
- int[] diffs = StreamUtility.diffStreams(isA, isB, allowableDifferenceRegions);
- if (diffs == null) {
- return true;
- }
- System.err.println("Diff from proof: ");
- for (int i = 0; i < diffs.length; i++) {
- System.err.println("diff at offset: 0x" + Integer.toHexString(diffs[i]));
- }
- return false;
- }
+// private static boolean compareStreams(InputStream isA, byte[] generatedContent) {
+//
+// InputStream isB = new ByteArrayInputStream(generatedContent);
+//
+// // The allowable regions where the generated file can differ from the
+// // proof should be small (i.e. much less than 1K)
+// int[] allowableDifferenceRegions = {
+// 0x0228, 16, // a region of the file containing the OS username
+// 0x506C, 8, // See RootProperty (super fields _seconds_2 and _days_2)
+// };
+// int[] diffs = StreamUtility.diffStreams(isA, isB, allowableDifferenceRegions);
+// if (diffs == null) {
+// return true;
+// }
+// System.err.println("Diff from proof: ");
+// for (int i = 0; i < diffs.length; i++) {
+// System.err.println("diff at offset: 0x" + Integer.toHexString(diffs[i]));
+// }
+// return false;
+// }
- /* package */ static void setCellValue(HSSFCell cell, String text) {
+ /* package */ static void setCellValue(HSSFCell cell, String text) {
cell.setCellValue(new HSSFRichTextString(text));
- }
+ }
- public void testAddToExistingSheet() {
+ @Test
+ public void testAddToExistingSheet() throws Exception {
// dvEmpty.xls is a simple one sheet workbook. With a DataValidations header record but no
// DataValidations. It's important that the example has one SHEETPROTECTION record.
sheet.addValidationData(dv);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
- try {
- wb.write(baos);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
+ wb.write(baos);
byte[] wbData = baos.toByteArray();
- if (false) { // TODO (Jul 2008) fix EventRecordFactory to process unknown records, (and DV records for that matter)
-
- ERFListener erfListener = null; // new MyERFListener();
- EventRecordFactory erf = new EventRecordFactory(erfListener, null);
- try {
- POIFSFileSystem fs = new POIFSFileSystem(new ByteArrayInputStream(baos.toByteArray()));
- erf.processRecords(fs.createDocumentInputStream("Workbook"));
- } catch (RecordFormatException e) {
- throw new RuntimeException(e);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
+// if (false) { // TODO (Jul 2008) fix EventRecordFactory to process unknown records, (and DV records for that matter)
+//
+// ERFListener erfListener = null; // new MyERFListener();
+// EventRecordFactory erf = new EventRecordFactory(erfListener, null);
+// try {
+// POIFSFileSystem fs = new POIFSFileSystem(new ByteArrayInputStream(baos.toByteArray()));
+// erf.processRecords(fs.createDocumentInputStream("Workbook"));
+// } catch (RecordFormatException e) {
+// throw new RuntimeException(e);
+// } catch (IOException e) {
+// throw new RuntimeException(e);
+// }
+// }
// else verify record ordering by navigating the raw bytes
byte[] dvHeaderRecStart= { (byte)0xB2, 0x01, 0x12, 0x00, };
// and the DV records, Excel will not be able to open the workbook without error.
if (nextSid == 0x0867) {
- throw new AssertionFailedError("Identified bug 45519");
+ fail("Identified bug 45519");
}
assertEquals(DVRecord.sid, nextSid);
+
+ wb.close();
}
+
private int findIndex(byte[] largeData, byte[] searchPattern) {
byte firstByte = searchPattern[0];
for (int i = 0; i < largeData.length; i++) {
return -1;
}
- public void testGetDataValidationsAny() {
+ @Test
+ public void testGetDataValidationsAny() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
List<HSSFDataValidation> list = sheet.getDataValidations();
DataValidationConstraint c = dv.getValidationConstraint();
assertEquals(ValidationType.ANY, c.getValidationType());
assertEquals(OperatorType.IGNORED, c.getOperator());
+
+ wb.close();
}
- public void testGetDataValidationsIntegerFormula() {
+ @Test
+ public void testGetDataValidationsIntegerFormula() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
List<HSSFDataValidation> list = sheet.getDataValidations();
assertEquals("A3", c.getFormula2());
assertEquals(null, c.getValue1());
assertEquals(null, c.getValue2());
+
+ wb.close();
}
- public void testGetDataValidationsIntegerValue() {
+ @Test
+ public void testGetDataValidationsIntegerValue() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
List<HSSFDataValidation> list = sheet.getDataValidations();
assertEquals(null, c.getFormula2());
assertEquals(new Double("100"), c.getValue1());
assertEquals(new Double("200"), c.getValue2());
+
+ wb.close();
}
- public void testGetDataValidationsDecimal() {
+ @Test
+ public void testGetDataValidationsDecimal() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
List<HSSFDataValidation> list = sheet.getDataValidations();
assertEquals(null, c.getFormula2());
assertEquals(null, c.getValue1());
assertEquals(new Double("200"), c.getValue2());
+
+ wb.close();
}
- public void testGetDataValidationsDate() {
+ @Test
+ public void testGetDataValidationsDate() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
List<HSSFDataValidation> list = sheet.getDataValidations();
assertEquals(OperatorType.EQUAL, c.getOperator());
assertEquals(null, c.getFormula1());
assertEquals(null, c.getFormula2());
- assertEquals(DateUtil.getExcelDate(DateUtil.parseYYYYMMDDDate("2014/10/25")), c.getValue1());
+ assertEquals(DateUtil.getExcelDate(DateUtil.parseYYYYMMDDDate("2014/10/25")), c.getValue1(), 0);
assertEquals(null, c.getValue2());
+
+ wb.close();
}
- public void testGetDataValidationsListExplicit() {
+ @Test
+ public void testGetDataValidationsListExplicit() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
List<HSSFDataValidation> list = sheet.getDataValidations();
assertEquals("aaa", values[0]);
assertEquals("bbb", values[1]);
assertEquals("ccc", values[2]);
+
+ wb.close();
}
- public void testGetDataValidationsListFormula() {
+ @Test
+ public void testGetDataValidationsListFormula() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
List<HSSFDataValidation> list = sheet.getDataValidations();
assertEquals(null, c.getFormula2());
assertEquals(null, c.getValue1());
assertEquals(null, c.getValue2());
+
+ wb.close();
}
- public void testGetDataValidationsFormula() {
+ @Test
+ public void testGetDataValidationsFormula() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet();
List<HSSFDataValidation> list = sheet.getDataValidations();
assertEquals(null, c.getFormula2());
assertEquals(null, c.getValue1());
assertEquals(null, c.getValue2());
+ wb.close();
}
}
package org.apache.poi.hssf.usermodel;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.lang.reflect.Field;
import org.apache.poi.hssf.HSSFITestDataProvider;
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.model.HSSFFormulaParser;
import org.apache.poi.hssf.record.NameRecord;
-import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.formula.FormulaType;
+import org.apache.poi.ss.formula.ptg.Ptg;
import org.apache.poi.ss.usermodel.BaseTestNamedRange;
import org.apache.poi.ss.util.AreaReference;
-import org.apache.poi.util.TempFile;
+import org.junit.Test;
/**
* Tests various functionality having to do with {@link org.apache.poi.ss.usermodel.Name}.
super(HSSFITestDataProvider.instance);
}
- public void testRepeatingRowsAndColumsNames() {
+ @Test
+ public void testRepeatingRowsAndColumsNames() throws Exception {
// First test that setting RR&C for same sheet more than once only creates a
// single Print_Titles built-in record
HSSFWorkbook wb = new HSSFWorkbook();
HSSFName nr1 = wb.getNameAt(0);
assertEquals("Print_Titles", nr1.getNameName());
- if (false) {
- // TODO - full column references not rendering properly, absolute markers not present either
- assertEquals("FirstSheet!$A:$A,FirstSheet!$1:$3", nr1.getRefersToFormula());
- } else {
+// if (false) {
+// // TODO - full column references not rendering properly, absolute markers not present either
+// assertEquals("FirstSheet!$A:$A,FirstSheet!$1:$3", nr1.getRefersToFormula());
+// } else {
assertEquals("FirstSheet!A:A,FirstSheet!$A$1:$IV$3", nr1.getRefersToFormula());
- }
+// }
// Save and re-open
HSSFWorkbook nwb = HSSFTestDataSamples.writeOutAndReadBack(wb);
+ wb.close();
assertEquals(1, nwb.getNumberOfNames());
nr1 = nwb.getNameAt(0);
assertEquals("Print_Titles", nr2.getNameName());
assertEquals("SecondSheet!B:C,SecondSheet!$A$1:$IV$1", nr2.getRefersToFormula());
- if (false) {
- // In case you fancy checking in excel, to ensure it
- // won't complain about the file now
- try {
- File tempFile = TempFile.createTempFile("POI-45126-", ".xls");
- FileOutputStream fout = new FileOutputStream(tempFile);
- nwb.write(fout);
- fout.close();
- System.out.println("check out " + tempFile.getAbsolutePath());
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
+// if (false) {
+// // In case you fancy checking in excel, to ensure it
+// // won't complain about the file now
+// try {
+// File tempFile = TempFile.createTempFile("POI-45126-", ".xls");
+// FileOutputStream fout = new FileOutputStream(tempFile);
+// nwb.write(fout);
+// fout.close();
+// System.out.println("check out " + tempFile.getAbsolutePath());
+// } catch (IOException e) {
+// throw new RuntimeException(e);
+// }
+// }
+ nwb.close();
}
- public void testNamedRange() {
- HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("Simple.xls");
+ @Test
+ public void testNamedRange() throws Exception {
+ HSSFWorkbook wb1 = HSSFTestDataSamples.openSampleWorkbook("Simple.xls");
//Creating new Named Range
- HSSFName newNamedRange = wb.createName();
+ HSSFName newNamedRange = wb1.createName();
//Getting Sheet Name for the reference
- String sheetName = wb.getSheetName(0);
+ String sheetName = wb1.getSheetName(0);
//Setting its name
newNamedRange.setNameName("RangeTest");
newNamedRange.setRefersToFormula(sheetName + "!$D$4:$E$8");
//Getting NAmed Range
- HSSFName namedRange1 = wb.getNameAt(0);
+ HSSFName namedRange1 = wb1.getNameAt(0);
//Getting it sheet name
sheetName = namedRange1.getSheetName();
// sanity check
SanityChecker c = new SanityChecker();
- c.checkHSSFWorkbook(wb);
+ c.checkHSSFWorkbook(wb1);
- wb = HSSFTestDataSamples.writeOutAndReadBack(wb);
- HSSFName nm =wb.getNameAt(wb.getNameIndex("RangeTest"));
+ HSSFWorkbook wb2 = HSSFTestDataSamples.writeOutAndReadBack(wb1);
+ HSSFName nm = wb2.getNameAt(wb2.getNameIndex("RangeTest"));
assertTrue("Name is "+nm.getNameName(),"RangeTest".equals(nm.getNameName()));
- assertEquals(wb.getSheetName(0)+"!$D$4:$E$8", nm.getRefersToFormula());
+ assertEquals(wb2.getSheetName(0)+"!$D$4:$E$8", nm.getRefersToFormula());
+ wb2.close();
+ wb1.close();
}
/**
* <p>
* Addresses Bug <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=9632" target="_bug">#9632</a>
*/
- public void testNamedRead() {
+ @Test
+ public void testNamedRead() throws Exception {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("namedinput.xls");
//Get index of the named range with the name = "NamedRangeName" , which was defined in input.xls as A1:D10
assertEquals(sheetName+"!$D$17:$G$27", namedRange2.getRefersToFormula());
assertEquals("SecondNamedRange", namedRange2.getNameName());
+
+ wb.close();
}
/**
* <p>
* Addresses Bug <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=16411" target="_bug">#16411</a>
*/
- public void testNamedReadModify() {
+ @Test
+ public void testNamedReadModify() throws Exception {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("namedinput.xls");
HSSFName name = wb.getNameAt(0);
name.setRefersToFormula(newReference);
assertEquals(newReference, name.getRefersToFormula());
+
+ wb.close();
}
/**
* Test to see if the print area can be retrieved from an excel created file
*/
- public void testPrintAreaFileRead() {
- HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook("SimpleWithPrintArea.xls");
+ @Test
+ public void testPrintAreaFileRead() throws Exception {
+ HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook("SimpleWithPrintArea.xls");
String sheetName = workbook.getSheetName(0);
String reference = sheetName+"!$A$1:$C$5";
assertEquals(reference, workbook.getPrintArea(0));
+ workbook.close();
}
-
- public void testDeletedReference() {
+ @Test
+ public void testDeletedReference() throws Exception {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("24207.xls");
assertEquals(2, wb.getNumberOfNames());
} catch (IllegalArgumentException e) { // TODO - use a stronger typed exception for this condition
// expected during successful test
}
+ wb.close();
}
/**
* must set the type of operands to Ptg.CLASS_REF,
* otherwise created named don't appear in the drop-down to the left of formula bar in Excel
*/
- public void testTypeOfRootPtg(){
+ @Test
+ public void testTypeOfRootPtg() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
wb.createSheet("CSCO");
for (int i = 0; i < ptgs.length; i++) {
assertEquals('R', ptgs[i].getRVAType());
}
-
+ wb.close();
}
}
package org.apache.poi.hssf.usermodel;
+import static org.junit.Assert.fail;
+
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
-
import org.apache.poi.hssf.record.BOFRecord;
import org.apache.poi.hssf.record.BoundSheetRecord;
import org.apache.poi.hssf.record.EOFRecord;
import org.apache.poi.hssf.record.NameRecord;
import org.apache.poi.hssf.record.Record;
import org.apache.poi.hssf.usermodel.SanityChecker.CheckRecord;
+import org.junit.Test;
/**
* A Test case for a test utility class.<br/>
*
* @author Glen Stampoultzis (glens at apache.org)
*/
-public final class TestSanityChecker extends TestCase {
+public final class TestSanityChecker {
private static final Record INTERFACEHDR = new InterfaceHdrRecord(InterfaceHdrRecord.CODEPAGE);
private static BoundSheetRecord createBoundSheetRec() {
return new BoundSheetRecord("Sheet1");
}
+
+ @Test
public void testCheckRecordOrder() {
final SanityChecker c = new SanityChecker();
List<Record> records = new ArrayList<Record>();
}
private static void confirmBadRecordOrder(final SanityChecker.CheckRecord[] check, Record[] recs) {
final SanityChecker c = new SanityChecker();
- final List records = Arrays.asList(recs);
+ final List<Record> records = Arrays.asList(recs);
try {
new Runnable() {
public void run() {
c.checkRecordOrder(records, check);
}
}.run();
- } catch (AssertionFailedError pass) {
+ } catch (AssertionError pass) {
// expected during normal test
return;
}
- throw new AssertionFailedError("Did not get failure exception as expected");
+ fail("Did not get failure exception as expected");
}
}
package org.apache.poi.poifs.storage;
-import junit.framework.Test;
-import junit.framework.TestSuite;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
* Tests for org.apache.poi.poifs.storage<br/>
- *
- * @author Josh Micich
*/
-public final class AllPOIFSStorageTests {
-
- public static Test suite() {
- TestSuite result = new TestSuite(AllPOIFSStorageTests.class.getName());
- result.addTestSuite(TestBATBlock.class);
- result.addTestSuite(TestBlockAllocationTableReader.class);
- result.addTestSuite(TestBlockAllocationTableWriter.class);
- result.addTestSuite(TestBlockListImpl.class);
- result.addTestSuite(TestDocumentBlock.class);
- result.addTestSuite(TestHeaderBlockReading.class);
- result.addTestSuite(TestHeaderBlockWriting.class);
- result.addTestSuite(TestPropertyBlock.class);
- result.addTestSuite(TestRawDataBlock.class);
- result.addTestSuite(TestRawDataBlockList.class);
- result.addTestSuite(TestSmallBlockTableReader.class);
- result.addTestSuite(TestSmallBlockTableWriter.class);
- result.addTestSuite(TestSmallDocumentBlock.class);
- result.addTestSuite(TestSmallDocumentBlockList.class);
- return result;
- }
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TestBATBlock.class,
+ TestBlockAllocationTableReader.class,
+ TestBlockAllocationTableWriter.class,
+ TestBlockListImpl.class,
+ TestDocumentBlock.class,
+ TestHeaderBlockReading.class,
+ TestHeaderBlockWriting.class,
+ TestPropertyBlock.class,
+ TestRawDataBlock.class,
+ TestRawDataBlockList.class,
+ TestSmallBlockTableReader.class,
+ TestSmallBlockTableWriter.class,
+ TestSmallDocumentBlock.class,
+ TestSmallDocumentBlockList.class
+})
+public class AllPOIFSStorageTests {
}
package org.apache.poi.poifs.storage;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
-import junit.framework.TestCase;
-
import org.apache.poi.poifs.common.POIFSConstants;
import org.apache.poi.util.LittleEndian;
import org.apache.poi.util.LittleEndianConsts;
+import org.junit.Test;
/**
* Class to test BlockListImpl functionality
*
* @author Marc Johnson
*/
-public final class TestBlockListImpl extends TestCase {
+public final class TestBlockListImpl {
private static final class BlockListTestImpl extends BlockListImpl {
public BlockListTestImpl() {
// no extra initialisation
return new BlockListTestImpl();
}
+ @Test
public void testZap() throws IOException {
BlockListImpl list = create();
}
}
-
+ @Test
public void testRemove() throws IOException {
BlockListImpl list = create();
RawDataBlock[] blocks = new RawDataBlock[ 5 ];
}
}
+ @Test
public void testSetBAT() throws IOException {
BlockListImpl list = create();
}
}
+ @Test
public void testFetchBlocks() throws IOException {
// strategy:
// that includes a reserved (XBAT) block, and one that
// points off into space somewhere
BlockListImpl list = create();
- List raw_blocks = new ArrayList();
+ List<RawDataBlock> raw_blocks = new ArrayList<RawDataBlock>();
byte[] data = new byte[ 512 ];
int offset = 0;
raw_blocks.add(
new RawDataBlock(new ByteArrayInputStream(new byte[ 0 ])));
}
- list.setBlocks(( RawDataBlock [] ) raw_blocks
- .toArray(new RawDataBlock[ 0 ]));
+ list.setBlocks(raw_blocks.toArray(new RawDataBlock[raw_blocks.size()]));
int[] blocks =
{
0
package org.apache.poi.poifs.storage;
+import static org.junit.Assert.assertEquals;
+
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.poifs.common.POIFSConstants;
-
-import junit.framework.TestCase;
+import org.apache.poi.poifs.property.Property;
+import org.junit.Test;
/**
* Class to test PropertyBlock functionality
- *
- * @author Marc Johnson
*/
-public final class TestPropertyBlock extends TestCase {
+public final class TestPropertyBlock {
- public void testCreatePropertyBlocks() {
+ @Test
+ public void testCreatePropertyBlocks() throws Exception {
// test with 0 properties
- List properties = new ArrayList();
+ List<Property> properties = new ArrayList<Property>();
BlockWritable[] blocks =
PropertyBlock.createPropertyBlockArray(POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS,properties);
}
}
- private static void verifyCorrect(BlockWritable[] blocks, byte[] testblock) {
+ private static void verifyCorrect(BlockWritable[] blocks, byte[] testblock)
+ throws IOException {
ByteArrayOutputStream stream = new ByteArrayOutputStream(512
* blocks.length);
- for (int j = 0; j < blocks.length; j++) {
- try {
- blocks[ j ].writeBlocks(stream);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
+ for (BlockWritable b : blocks) {
+ b.writeBlocks(stream);
}
byte[] output = stream.toByteArray();
assertEquals(testblock.length, output.length);
- for (int j = 0; j < testblock.length; j++)
- {
+ for (int j = 0; j < testblock.length; j++) {
assertEquals("mismatch at offset " + j, testblock[ j ],
output[ j ]);
}
package org.apache.poi.ss.formula.eval;
-import java.io.FileOutputStream;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
import java.io.IOException;
import java.io.InputStream;
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
-
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellValue;
+import org.junit.Test;
/**
* Miscellaneous tests for bugzilla entries.<p/> The test name contains the
* bugzilla bug id.
- *
- *
- * @author Josh Micich
*/
-public final class TestFormulaBugs extends TestCase {
+public final class TestFormulaBugs {
/**
* Bug 27349 - VLOOKUP with reference to another sheet.<p/> This test was
* added <em>long</em> after the relevant functionality was fixed.
*/
- public void test27349() {
+ @Test
+ public void test27349() throws Exception {
// 27349-vlookupAcrossSheets.xls is bugzilla/attachment.cgi?id=10622
InputStream is = HSSFTestDataSamples.openSampleFileStream("27349-vlookupAcrossSheets.xls");
- HSSFWorkbook wb;
- try {
- // original bug may have thrown exception here, or output warning to
- // stderr
- wb = new HSSFWorkbook(is);
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
+ // original bug may have thrown exception here,
+ // or output warning to stderr
+ HSSFWorkbook wb = new HSSFWorkbook(is);
HSSFSheet sheet = wb.getSheetAt(0);
HSSFRow row = sheet.getRow(1);
assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType());
assertEquals(3.0, cv.getNumberValue(), 0.0);
+
+ wb.close();
+ is.close();
}
/**
*
* seems to be a duplicate of 24925
*/
- public void test27405() {
+ @Test
+ public void test27405() throws Exception {
HSSFWorkbook wb = new HSSFWorkbook();
HSSFSheet sheet = wb.createSheet("input");
cell = row.createCell(3); // D5
cell.setCellFormula("IF(ISNUMBER(b1),b1,b2)");
- if (false) { // set true to check excel file manually
- // bug report mentions 'Editing the formula in excel "fixes" the problem.'
- try {
- FileOutputStream fileOut = new FileOutputStream("27405output.xls");
- wb.write(fileOut);
- fileOut.close();
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
+// if (false) { // set true to check excel file manually
+// // bug report mentions 'Editing the formula in excel "fixes" the problem.'
+// try {
+// FileOutputStream fileOut = new FileOutputStream("27405output.xls");
+// wb.write(fileOut);
+// fileOut.close();
+// } catch (IOException e) {
+// throw new RuntimeException(e);
+// }
+// }
// use POI's evaluator as an extra sanity check
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
cv = fe.evaluate(row.getCell(1));
assertEquals(HSSFCell.CELL_TYPE_BOOLEAN, cv.getCellType());
assertEquals(true, cv.getBooleanValue());
+
+ wb.close();
}
/**
* Bug 42448 - Can't parse SUMPRODUCT(A!C7:A!C67, B8:B68) / B69 <p/>
* @throws IOException
*/
+ @Test
public void test42448() throws IOException {
HSSFWorkbook wb = new HSSFWorkbook();
+ HSSFSheet sheet1 = wb.createSheet("Sheet1");
+
+ HSSFRow row = sheet1.createRow(0);
+ HSSFCell cell = row.createCell(0);
+
+ // it's important to create the referenced sheet first
+ HSSFSheet sheet2 = wb.createSheet("A"); // note name 'A'
+ // TODO - POI crashes if the formula is added before this sheet
+ // RuntimeException("Zero length string is an invalid sheet name")
+ // Excel doesn't crash but the formula doesn't work until it is
+ // re-entered
+
+ String inputFormula = "SUMPRODUCT(A!C7:A!C67, B8:B68) / B69"; // as per bug report
try {
- HSSFSheet sheet1 = wb.createSheet("Sheet1");
-
- HSSFRow row = sheet1.createRow(0);
- HSSFCell cell = row.createCell(0);
-
- // it's important to create the referenced sheet first
- HSSFSheet sheet2 = wb.createSheet("A"); // note name 'A'
- // TODO - POI crashes if the formula is added before this sheet
- // RuntimeException("Zero length string is an invalid sheet name")
- // Excel doesn't crash but the formula doesn't work until it is
- // re-entered
-
- String inputFormula = "SUMPRODUCT(A!C7:A!C67, B8:B68) / B69"; // as per bug report
- try {
- cell.setCellFormula(inputFormula);
- } catch (StringIndexOutOfBoundsException e) {
- throw new AssertionFailedError("Identified bug 42448");
- }
-
- assertEquals("SUMPRODUCT(A!C7:A!C67,B8:B68)/B69", cell.getCellFormula());
-
- // might as well evaluate the sucker...
-
- addCell(sheet2, 5, 2, 3.0); // A!C6
- addCell(sheet2, 6, 2, 4.0); // A!C7
- addCell(sheet2, 66, 2, 5.0); // A!C67
- addCell(sheet2, 67, 2, 6.0); // A!C68
-
- addCell(sheet1, 6, 1, 7.0); // B7
- addCell(sheet1, 7, 1, 8.0); // B8
- addCell(sheet1, 67, 1, 9.0); // B68
- addCell(sheet1, 68, 1, 10.0); // B69
-
- double expectedResult = (4.0 * 8.0 + 5.0 * 9.0) / 10.0;
-
- HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
- CellValue cv = fe.evaluate(cell);
-
- assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType());
- assertEquals(expectedResult, cv.getNumberValue(), 0.0);
- } finally {
- wb.close();
+ cell.setCellFormula(inputFormula);
+ } catch (StringIndexOutOfBoundsException e) {
+ fail("Identified bug 42448");
}
+
+ assertEquals("SUMPRODUCT(A!C7:A!C67,B8:B68)/B69", cell.getCellFormula());
+
+ // might as well evaluate the sucker...
+
+ addCell(sheet2, 5, 2, 3.0); // A!C6
+ addCell(sheet2, 6, 2, 4.0); // A!C7
+ addCell(sheet2, 66, 2, 5.0); // A!C67
+ addCell(sheet2, 67, 2, 6.0); // A!C68
+
+ addCell(sheet1, 6, 1, 7.0); // B7
+ addCell(sheet1, 7, 1, 8.0); // B8
+ addCell(sheet1, 67, 1, 9.0); // B68
+ addCell(sheet1, 68, 1, 10.0); // B69
+
+ double expectedResult = (4.0 * 8.0 + 5.0 * 9.0) / 10.0;
+
+ HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
+ CellValue cv = fe.evaluate(cell);
+
+ assertEquals(HSSFCell.CELL_TYPE_NUMERIC, cv.getCellType());
+ assertEquals(expectedResult, cv.getNumberValue(), 0.0);
+
+ wb.close();
}
private static void addCell(HSSFSheet sheet, int rowIx, int colIx,
package org.apache.poi.ss.formula.function;
-import junit.framework.Test;
-import junit.framework.TestSuite;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
/**
* Collects all tests for this <tt>org.apache.poi.hssf.record.formula.function</tt>.
- *
- * @author Josh Micich
*/
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+ TestFunctionMetadataRegistry.class,
+ TestParseMissingBuiltInFuncs.class,
+ TestReadMissingBuiltInFuncs.class
+})
public class AllFormulaFunctionTests {
-
- public static Test suite() {
- TestSuite result = new TestSuite(AllFormulaFunctionTests.class.getName());
- result.addTestSuite(TestFunctionMetadataRegistry.class);
- result.addTestSuite(TestParseMissingBuiltInFuncs.class);
- result.addTestSuite(TestReadMissingBuiltInFuncs.class);
- return result;
- }
}
File outFile = new File("functionMetadata-asGenerated.txt");
- if (false) { // set true to use local file
- File dir = new File("c:/temp");
- File effDocFile = new File(dir, SOURCE_DOC_FILE_NAME);
- processFile(effDocFile, outFile);
- return;
- }
+// if (false) { // set true to use local file
+// File dir = new File("c:/temp");
+// File effDocFile = new File(dir, SOURCE_DOC_FILE_NAME);
+// processFile(effDocFile, outFile);
+// return;
+// }
File tempEFFDocFile = downloadSourceFile();
processFile(tempEFFDocFile, outFile);
package org.apache.poi.ss.formula.function;
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+
+import java.io.IOException;
import org.apache.poi.hssf.model.HSSFFormulaParser;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.formula.ptg.AbstractFunctionPtg;
import org.apache.poi.ss.formula.ptg.FuncPtg;
import org.apache.poi.ss.formula.ptg.FuncVarPtg;
import org.apache.poi.ss.formula.ptg.Ptg;
-import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.junit.Test;
+
+import junit.framework.AssertionFailedError;
/**
* Tests parsing of some built-in functions that were not properly
* registered in POI as of bug #44675, #44733 (March/April 2008).
- *
- * @author Josh Micich
*/
-public final class TestParseMissingBuiltInFuncs extends TestCase {
+public final class TestParseMissingBuiltInFuncs {
- private static Ptg[] parse(String formula) {
+ private static Ptg[] parse(String formula) throws IOException {
HSSFWorkbook book = new HSSFWorkbook();
- return HSSFFormulaParser.parse(formula, book);
+ Ptg[] ptgs = HSSFFormulaParser.parse(formula, book);
+ book.close();
+ return ptgs;
}
- private static void confirmFunc(String formula, int expPtgArraySize, boolean isVarArgFunc, int funcIx) {
+
+ private static void confirmFunc(String formula, int expPtgArraySize, boolean isVarArgFunc, int funcIx)
+ throws IOException {
Ptg[] ptgs = parse(formula);
Ptg ptgF = ptgs[ptgs.length-1]; // func is last RPN token in all these formulas
}
assertEquals(expPtgArraySize, ptgs.length);
assertEquals(funcIx, func.getFunctionIndex());
- Class expCls = isVarArgFunc ? FuncVarPtg.class : FuncPtg.class;
+ Class<? extends AbstractFunctionPtg> expCls = isVarArgFunc ? FuncVarPtg.class : FuncPtg.class;
assertEquals(expCls, ptgF.getClass());
// check that parsed Ptg array converts back to formula text OK
HSSFWorkbook book = new HSSFWorkbook();
String reRenderedFormula = HSSFFormulaParser.toFormulaString(book, ptgs);
assertEquals(formula, reRenderedFormula);
+ book.close();
}
- public void testDatedif() {
+ @Test
+ public void testDatedif() throws IOException {
int expSize = 4; // NB would be 5 if POI added tAttrVolatile properly
confirmFunc("DATEDIF(NOW(),NOW(),\"d\")", expSize, false, 351);
}
- public void testDdb() {
+ @Test
+ public void testDdb() throws IOException {
confirmFunc("DDB(1,1,1,1,1)", 6, true, 144);
}
- public void testAtan() {
+
+ @Test
+ public void testAtan() throws IOException {
confirmFunc("ATAN(1)", 2, false, 18);
}
- public void testUsdollar() {
+ @Test
+ public void testUsdollar() throws IOException {
confirmFunc("USDOLLAR(1)", 2, true, 204);
}
- public void testDBCS() {
+ @Test
+ public void testDBCS() throws IOException {
confirmFunc("DBCS(\"abc\")", 2, false, 215);
}
- public void testIsnontext() {
+
+ @Test
+ public void testIsnontext() throws IOException {
confirmFunc("ISNONTEXT(\"abc\")", 2, false, 190);
}
- public void testDproduct() {
+
+ @Test
+ public void testDproduct() throws IOException {
confirmFunc("DPRODUCT(C1:E5,\"HarvestYield\",G1:H2)", 4, false, 189);
}
}
--- /dev/null
+/* ====================================================================\r
+ Licensed to the Apache Software Foundation (ASF) under one or more\r
+ contributor license agreements. See the NOTICE file distributed with\r
+ this work for additional information regarding copyright ownership.\r
+ The ASF licenses this file to You under the Apache License, Version 2.0\r
+ (the "License"); you may not use this file except in compliance with\r
+ the License. You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+==================================================================== */\r
+\r
+package org.apache.poi.ss.formula.functions;\r
+\r
+import org.junit.runner.RunWith;\r
+import org.junit.runners.Suite;\r
+\r
+/**\r
+ * Direct tests for all implementors of <code>Function</code>.\r
+ */\r
+@RunWith(Suite.class)\r
+@Suite.SuiteClasses({\r
+ TestCodeFunctionsFromSpreadsheet.class,\r
+ TestComplexFunctionsFromSpreadsheet.class,\r
+ TestDeltaFunctionsFromSpreadsheet.class,\r
+ TestDGetFunctionsFromSpreadsheet.class,\r
+ TestDStarFunctionsFromSpreadsheet.class,\r
+ TestFactDoubleFunctionsFromSpreadsheet.class,\r
+ TestFixedFunctionsFromSpreadsheet.class,\r
+ TestImaginaryFunctionsFromSpreadsheet.class,\r
+ TestImRealFunctionsFromSpreadsheet.class,\r
+ TestIndexFunctionFromSpreadsheet.class,\r
+ TestIndirectFunctionFromSpreadsheet.class,\r
+ TestLookupFunctionsFromSpreadsheet.class,\r
+ TestMatchFunctionsFromSpreadsheet.class,\r
+ TestQuotientFunctionsFromSpreadsheet.class,\r
+ TestReptFunctionsFromSpreadsheet.class,\r
+ TestRomanFunctionsFromSpreadsheet.class,\r
+ TestWeekNumFunctionsFromSpreadsheet.class,\r
+ TestWeekNumFunctionsFromSpreadsheet2013.class\r
+})\r
+public class AllSpreadsheetBasedTests {\r
+}\r
\r
package org.apache.poi.ss.formula.functions;\r
\r
-import java.io.PrintStream;\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+import static org.junit.Assert.fail;\r
\r
-import junit.framework.Assert;\r
-import junit.framework.AssertionFailedError;\r
-import junit.framework.TestCase;\r
+import java.util.ArrayList;\r
+import java.util.Collection;\r
+import java.util.List;\r
+import java.util.Locale;\r
\r
import org.apache.poi.hssf.HSSFTestDataSamples;\r
-import org.apache.poi.ss.formula.eval.ErrorEval;\r
import org.apache.poi.hssf.usermodel.HSSFCell;\r
import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;\r
import org.apache.poi.hssf.usermodel.HSSFRow;\r
import org.apache.poi.hssf.usermodel.HSSFSheet;\r
import org.apache.poi.hssf.usermodel.HSSFWorkbook;\r
import org.apache.poi.hssf.util.CellReference;\r
+import org.apache.poi.ss.formula.eval.ErrorEval;\r
import org.apache.poi.ss.usermodel.CellValue;\r
+import org.junit.Test;\r
+import org.junit.runner.RunWith;\r
+import org.junit.runners.Parameterized;\r
+import org.junit.runners.Parameterized.Parameter;\r
\r
-/**\r
- * \r
- */\r
-public abstract class BaseTestFunctionsFromSpreadsheet extends TestCase {\r
-\r
- private static final class Result {\r
- public static final int SOME_EVALUATIONS_FAILED = -1;\r
- public static final int ALL_EVALUATIONS_SUCCEEDED = +1;\r
- public static final int NO_EVALUATIONS_FOUND = 0;\r
- }\r
+@RunWith(Parameterized.class)\r
+public abstract class BaseTestFunctionsFromSpreadsheet {\r
\r
/**\r
* This class defines constants for navigating around the test data spreadsheet used for these tests.\r
*/\r
- private static final class SS {\r
-\r
+ interface SS {\r
/** Name of the test spreadsheet (found in the standard test data folder) */\r
\r
-\r
/** Name of the first sheet in the spreadsheet (contains comments) */\r
- public final static String README_SHEET_NAME = "Read Me";\r
+ String README_SHEET_NAME = "Read Me";\r
\r
/** Row (zero-based) in each sheet where the evaluation cases start. */\r
- public static final int START_TEST_CASES_ROW_INDEX = 4; // Row '5'\r
+ int START_TEST_CASES_ROW_INDEX = 4; // Row '5'\r
/** Index of the column that contains the function names */\r
- public static final int COLUMN_INDEX_MARKER = 0; // Column 'A'\r
- public static final int COLUMN_INDEX_EVALUATION = 1; // Column 'B'\r
- public static final int COLUMN_INDEX_EXPECTED_RESULT = 2; // Column 'C'\r
- public static final int COLUMN_ROW_COMMENT = 3; // Column 'D'\r
+ int COLUMN_INDEX_MARKER = 0; // Column 'A'\r
+ int COLUMN_INDEX_EVALUATION = 1; // Column 'B'\r
+ int COLUMN_INDEX_EXPECTED_RESULT = 2; // Column 'C'\r
+ int COLUMN_ROW_COMMENT = 3; // Column 'D'\r
\r
/** Used to indicate when there are no more test cases on the current sheet */\r
- public static final String TEST_CASES_END_MARKER = "<end>";\r
+ String TEST_CASES_END_MARKER = "<end>";\r
/** Used to indicate that the test on the current row should be ignored */\r
- public static final String SKIP_CURRENT_TEST_CASE_MARKER = "<skip>";\r
+ String SKIP_CURRENT_TEST_CASE_MARKER = "<skip>";\r
\r
}\r
\r
- // Note - multiple failures are aggregated before ending.\r
- // If one or more functions fail, a single AssertionFailedError is thrown at the end\r
- private int _sheetFailureCount;\r
- private int _sheetSuccessCount;\r
- private int _evaluationFailureCount;\r
- private int _evaluationSuccessCount;\r
-\r
-\r
-\r
- private static void confirmExpectedResult(String msg, HSSFCell expected, CellValue actual) {\r
- if (expected == null) {\r
- throw new AssertionFailedError(msg + " - Bad setup data expected value is null");\r
- }\r
- if(actual == null) {\r
- throw new AssertionFailedError(msg + " - actual value was null");\r
- }\r
- if(expected.getCellType() == HSSFCell.CELL_TYPE_ERROR) {\r
- confirmErrorResult(msg, expected.getErrorCellValue(), actual);\r
- return;\r
- }\r
- if(actual.getCellType() == HSSFCell.CELL_TYPE_ERROR) {\r
- throw unexpectedError(msg, expected, actual.getErrorValue());\r
- }\r
- if(actual.getCellType() != expected.getCellType()) {\r
- throw wrongTypeError(msg, expected, actual);\r
- }\r
+ @Parameter(value = 0)\r
+ public String testName;\r
+ @Parameter(value = 1)\r
+ public String filename;\r
+ @Parameter(value = 2)\r
+ public HSSFSheet sheet;\r
+ @Parameter(value = 3)\r
+ public int formulasRowIdx;\r
+ @Parameter(value = 4)\r
+ public HSSFFormulaEvaluator evaluator;\r
\r
\r
- switch (expected.getCellType()) {\r
- case HSSFCell.CELL_TYPE_BOOLEAN:\r
- assertEquals(msg, expected.getBooleanCellValue(), actual.getBooleanValue());\r
- break;\r
- case HSSFCell.CELL_TYPE_FORMULA: // will never be used, since we will call method after formula evaluation\r
- throw new IllegalStateException("Cannot expect formula as result of formula evaluation: " + msg);\r
- case HSSFCell.CELL_TYPE_NUMERIC:\r
- assertEquals(expected.getNumericCellValue(), actual.getNumberValue(), 0.0);\r
- break;\r
- case HSSFCell.CELL_TYPE_STRING:\r
- assertEquals(msg, expected.getRichStringCellValue().getString(), actual.getStringValue());\r
- break;\r
- }\r
- }\r
+ \r
+ protected static Collection<Object[]> data(Class<? extends BaseTestFunctionsFromSpreadsheet> clazz, String filename) throws Exception {\r
+ HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook(filename);\r
+ confirmReadMeSheet(workbook, clazz);\r
\r
+ List<Object[]> data = new ArrayList<Object[]>();\r
\r
- private static AssertionFailedError wrongTypeError(String msgPrefix, HSSFCell expectedCell, CellValue actualValue) {\r
- return new AssertionFailedError(msgPrefix + " Result type mismatch. Evaluated result was "\r
- + actualValue.formatAsString()\r
- + " but the expected result was "\r
- + formatValue(expectedCell)\r
- );\r
- }\r
- private static AssertionFailedError unexpectedError(String msgPrefix, HSSFCell expected, int actualErrorCode) {\r
- return new AssertionFailedError(msgPrefix + " Error code ("\r
- + ErrorEval.getText(actualErrorCode)\r
- + ") was evaluated, but the expected result was "\r
- + formatValue(expected)\r
- );\r
- }\r
-\r
-\r
- private static void confirmErrorResult(String msgPrefix, int expectedErrorCode, CellValue actual) {\r
- if(actual.getCellType() != HSSFCell.CELL_TYPE_ERROR) {\r
- throw new AssertionFailedError(msgPrefix + " Expected cell error ("\r
- + ErrorEval.getText(expectedErrorCode) + ") but actual value was "\r
- + actual.formatAsString());\r
- }\r
- if(expectedErrorCode != actual.getErrorValue()) {\r
- throw new AssertionFailedError(msgPrefix + " Expected cell error code ("\r
- + ErrorEval.getText(expectedErrorCode)\r
- + ") but actual error code was ("\r
- + ErrorEval.getText(actual.getErrorValue())\r
- + ")");\r
- }\r
- }\r
-\r
-\r
- private static String formatValue(HSSFCell expecedCell) {\r
- switch (expecedCell.getCellType()) {\r
- case HSSFCell.CELL_TYPE_BLANK: return "<blank>";\r
- case HSSFCell.CELL_TYPE_BOOLEAN: return String.valueOf(expecedCell.getBooleanCellValue());\r
- case HSSFCell.CELL_TYPE_NUMERIC: return String.valueOf(expecedCell.getNumericCellValue());\r
- case HSSFCell.CELL_TYPE_STRING: return expecedCell.getRichStringCellValue().getString();\r
- }\r
- throw new RuntimeException("Unexpected cell type of expected value (" + expecedCell.getCellType() + ")");\r
- }\r
-\r
-\r
- protected void setUp() {\r
- _sheetFailureCount = 0;\r
- _sheetSuccessCount = 0;\r
- _evaluationFailureCount = 0;\r
- _evaluationSuccessCount = 0;\r
- }\r
-\r
- public void testFunctionsFromTestSpreadsheet() {\r
- HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook(this.getFilename());\r
-\r
- confirmReadMeSheet(workbook);\r
int nSheets = workbook.getNumberOfSheets();\r
- for(int i=1; i< nSheets; i++) {\r
- int sheetResult = processTestSheet(workbook, i, workbook.getSheetName(i));\r
- switch(sheetResult) {\r
- case Result.ALL_EVALUATIONS_SUCCEEDED: _sheetSuccessCount ++; break;\r
- case Result.SOME_EVALUATIONS_FAILED: _sheetFailureCount ++; break;\r
- }\r
- }\r
-\r
- // confirm results\r
- String successMsg = "There were "\r
- + _sheetSuccessCount + " successful sheets(s) and "\r
- + _evaluationSuccessCount + " function(s) without error";\r
- if(_sheetFailureCount > 0) {\r
- String msg = _sheetFailureCount + " sheets(s) failed with "\r
- + _evaluationFailureCount + " evaluation(s). " + successMsg;\r
- throw new AssertionFailedError(msg);\r
- }\r
- if(false) { // normally no output for successful tests\r
- System.out.println(getClass().getName() + ": " + successMsg);\r
+ for(int sheetIdx=1; sheetIdx< nSheets; sheetIdx++) {\r
+ HSSFSheet sheet = workbook.getSheetAt(sheetIdx);\r
+ processFunctionGroup(data, sheet, SS.START_TEST_CASES_ROW_INDEX, null, filename);\r
}\r
+ \r
+ workbook.close();\r
+ \r
+ return data;\r
}\r
\r
- protected abstract String getFilename();\r
-\r
- private int processTestSheet(HSSFWorkbook workbook, int sheetIndex, String sheetName) {\r
- HSSFSheet sheet = workbook.getSheetAt(sheetIndex);\r
- HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(workbook);\r
- int maxRows = sheet.getLastRowNum()+1;\r
- int result = Result.NO_EVALUATIONS_FOUND; // so far\r
+ private static void processFunctionGroup(List<Object[]> data, HSSFSheet sheet, final int startRowIndex, String testFocusFunctionName, String filename) {\r
+ HSSFFormulaEvaluator evaluator = new HSSFFormulaEvaluator(sheet.getWorkbook());\r
\r
- String currentGroupComment = null;\r
- for(int rowIndex=SS.START_TEST_CASES_ROW_INDEX; rowIndex<maxRows; rowIndex++) {\r
+ String currentGroupComment = "";\r
+ final int maxRows = sheet.getLastRowNum()+1;\r
+ for(int rowIndex=startRowIndex; rowIndex<maxRows; rowIndex++) {\r
HSSFRow r = sheet.getRow(rowIndex);\r
- String newMarkerValue = getMarkerColumnValue(r);\r
if(r == null) {\r
continue;\r
}\r
+ String newMarkerValue = getCellTextValue(r, SS.COLUMN_INDEX_MARKER, "marker"); \r
if(SS.TEST_CASES_END_MARKER.equalsIgnoreCase(newMarkerValue)) {\r
// normal exit point\r
- return result;\r
+ return;\r
}\r
if(SS.SKIP_CURRENT_TEST_CASE_MARKER.equalsIgnoreCase(newMarkerValue)) {\r
// currently disabled test case row\r
if(newMarkerValue != null) {\r
currentGroupComment = newMarkerValue;\r
}\r
- HSSFCell c = r.getCell(SS.COLUMN_INDEX_EVALUATION);\r
- if (c == null || c.getCellType() != HSSFCell.CELL_TYPE_FORMULA) {\r
+ HSSFCell evalCell = r.getCell(SS.COLUMN_INDEX_EVALUATION);\r
+ if (evalCell == null || evalCell.getCellType() != HSSFCell.CELL_TYPE_FORMULA) {\r
continue;\r
}\r
- CellValue actualValue = evaluator.evaluate(c);\r
- HSSFCell expectedValueCell = r.getCell(SS.COLUMN_INDEX_EXPECTED_RESULT);\r
- String rowComment = getRowCommentColumnValue(r);\r
-\r
- String msgPrefix = formatTestCaseDetails(this.getFilename(),sheetName, r.getRowNum(), c, currentGroupComment, rowComment);\r
- try {\r
- confirmExpectedResult(msgPrefix, expectedValueCell, actualValue);\r
- _evaluationSuccessCount ++;\r
- if(result != Result.SOME_EVALUATIONS_FAILED) {\r
- result = Result.ALL_EVALUATIONS_SUCCEEDED;\r
- }\r
- } catch (RuntimeException e) {\r
- _evaluationFailureCount ++;\r
- printShortStackTrace(System.err, e);\r
- result = Result.SOME_EVALUATIONS_FAILED;\r
- } catch (AssertionFailedError e) {\r
- _evaluationFailureCount ++;\r
- printShortStackTrace(System.err, e);\r
- result = Result.SOME_EVALUATIONS_FAILED;\r
- }\r
+ String rowComment = getCellTextValue(r, SS.COLUMN_ROW_COMMENT, "row comment");\r
\r
+ String testName = (currentGroupComment+'\n'+rowComment).replace("null", "").trim().replace("\n", " - ");\r
+ if ("".equals(testName)) {\r
+ testName = evalCell.getCellFormula();\r
+ }\r
+ \r
+ data.add(new Object[]{testName, filename, sheet, rowIndex, evaluator});\r
}\r
- throw new RuntimeException("Missing end marker '" + SS.TEST_CASES_END_MARKER\r
- + "' on sheet '" + sheetName + "'");\r
-\r
+ fail("Missing end marker '" + SS.TEST_CASES_END_MARKER + "' on sheet '" + sheet.getSheetName() + "'");\r
}\r
\r
+ @Test\r
+ public void processFunctionRow() throws Exception {\r
+ HSSFRow r = sheet.getRow(formulasRowIdx);\r
+ HSSFCell evalCell = r.getCell(SS.COLUMN_INDEX_EVALUATION);\r
+ HSSFCell expectedCell = r.getCell(SS.COLUMN_INDEX_EXPECTED_RESULT);\r
+ \r
+ CellReference cr = new CellReference(sheet.getSheetName(), formulasRowIdx, evalCell.getColumnIndex(), false, false);\r
+ String msg = String.format(Locale.ROOT, "In %s %s {=%s} '%s'"\r
+ , filename, cr.formatAsString(), evalCell.getCellFormula(), testName);\r
\r
- private static String formatTestCaseDetails(String filename, String sheetName, int rowIndex, HSSFCell c, String currentGroupComment,\r
- String rowComment) {\r
+ CellValue actualValue = evaluator.evaluate(evalCell);\r
\r
- StringBuffer sb = new StringBuffer();\r
+ assertNotNull(msg + " - Bad setup data expected value is null", expectedCell);\r
+ assertNotNull(msg + " - actual value was null", actualValue);\r
\r
- sb.append("In ").append(filename).append(" ");\r
+ if (expectedCell.getCellType() == HSSFCell.CELL_TYPE_ERROR) {\r
+ int expectedErrorCode = expectedCell.getErrorCellValue();\r
+ assertEquals(msg, HSSFCell.CELL_TYPE_ERROR, actualValue.getCellType());\r
+ assertEquals(msg, ErrorEval.getText(expectedErrorCode), actualValue.formatAsString());\r
+ assertEquals(msg, expectedErrorCode, actualValue.getErrorValue());\r
+ assertEquals(msg, ErrorEval.getText(expectedErrorCode), ErrorEval.getText(actualValue.getErrorValue()));\r
+ return;\r
+ }\r
\r
- CellReference cr = new CellReference(sheetName, rowIndex, c.getColumnIndex(), false, false);\r
- sb.append(cr.formatAsString());\r
- sb.append(" {=").append(c.getCellFormula()).append("}");\r
+ // unexpected error\r
+ assertNotEquals(msg, HSSFCell.CELL_TYPE_ERROR, actualValue.getCellType());\r
+ assertNotEquals(msg, formatValue(expectedCell), ErrorEval.getText(actualValue.getErrorValue()));\r
\r
- if(currentGroupComment != null) {\r
- sb.append(" '");\r
- sb.append(currentGroupComment);\r
- if(rowComment != null) {\r
- sb.append(" - ");\r
- sb.append(rowComment);\r
- }\r
- sb.append("' ");\r
- } else {\r
- if(rowComment != null) {\r
- sb.append(" '");\r
- sb.append(rowComment);\r
- sb.append("' ");\r
- }\r
- }\r
+ // wrong type error\r
+ assertEquals(msg, expectedCell.getCellType(), actualValue.getCellType());\r
\r
- return sb.toString();\r
+ switch (expectedCell.getCellType()) {\r
+ case HSSFCell.CELL_TYPE_BOOLEAN:\r
+ assertEquals(msg, expectedCell.getBooleanCellValue(), actualValue.getBooleanValue());\r
+ break;\r
+ case HSSFCell.CELL_TYPE_FORMULA: // will never be used, since we will call method after formula evaluation\r
+ fail("Cannot expect formula as result of formula evaluation: " + msg);\r
+ case HSSFCell.CELL_TYPE_NUMERIC:\r
+ assertEquals(expectedCell.getNumericCellValue(), actualValue.getNumberValue(), 0.0);\r
+ break;\r
+ case HSSFCell.CELL_TYPE_STRING:\r
+ assertEquals(msg, expectedCell.getRichStringCellValue().getString(), actualValue.getStringValue());\r
+ break;\r
+ }\r
}\r
\r
/**\r
* cells. This back-link is to make it easy to find this class if a reader encounters the\r
* spreadsheet first.\r
*/\r
- private void confirmReadMeSheet(HSSFWorkbook workbook) {\r
+ private static void confirmReadMeSheet(HSSFWorkbook workbook, Class<? extends BaseTestFunctionsFromSpreadsheet> clazz) {\r
String firstSheetName = workbook.getSheetName(0);\r
- if(!firstSheetName.equalsIgnoreCase(SS.README_SHEET_NAME)) {\r
- throw new RuntimeException("First sheet's name was '" + firstSheetName + "' but expected '" + SS.README_SHEET_NAME + "'");\r
- }\r
+ assertTrue("First sheet's name was '" + firstSheetName + "' but expected '" + SS.README_SHEET_NAME + "'",\r
+ firstSheetName.equalsIgnoreCase(SS.README_SHEET_NAME));\r
HSSFSheet sheet = workbook.getSheetAt(0);\r
String specifiedClassName = sheet.getRow(2).getCell(0).getRichStringCellValue().getString();\r
- assertEquals("Test class name in spreadsheet comment", getClass().getName(), specifiedClassName);\r
- }\r
-\r
-\r
- /**\r
- * Useful to keep output concise when expecting many failures to be reported by this test case\r
- */\r
- private static void printShortStackTrace(PrintStream ps, Throwable e) {\r
- StackTraceElement[] stes = e.getStackTrace();\r
-\r
- int startIx = 0;\r
- // skip any top frames inside junit.framework.Assert\r
- while(startIx<stes.length) {\r
- if(!stes[startIx].getClassName().equals(Assert.class.getName())) {\r
- break;\r
- }\r
- startIx++;\r
- }\r
- // skip bottom frames (part of junit framework)\r
- int endIx = startIx+1;\r
- while(endIx < stes.length) {\r
- if(stes[endIx].getClassName().equals(TestCase.class.getName())) {\r
- break;\r
- }\r
- endIx++;\r
- }\r
- if(startIx >= endIx) {\r
- // something went wrong. just print the whole stack trace\r
- e.printStackTrace(ps);\r
- }\r
- endIx -= 4; // skip 4 frames of reflection invocation\r
- ps.println(e.toString());\r
- for(int i=startIx; i<endIx; i++) {\r
- ps.println("\tat " + stes[i].toString());\r
- }\r
-\r
- }\r
-\r
- private static String getRowCommentColumnValue(HSSFRow r) {\r
- return getCellTextValue(r, SS.COLUMN_ROW_COMMENT, "row comment");\r
- }\r
-\r
- private static String getMarkerColumnValue(HSSFRow r) {\r
- return getCellTextValue(r, SS.COLUMN_INDEX_MARKER, "marker");\r
+ assertEquals("Test class name in spreadsheet comment", clazz.getName(), specifiedClassName);\r
}\r
\r
/**\r
return cell.getRichStringCellValue().getString();\r
}\r
\r
- throw new RuntimeException("Bad cell type for '" + columnName + "' column: ("\r
+ fail("Bad cell type for '" + columnName + "' column: ("\r
+ cell.getCellType() + ") row (" + (r.getRowNum() +1) + ")");\r
+ return "";\r
}\r
\r
+ private static String formatValue(HSSFCell expecedCell) {\r
+ switch (expecedCell.getCellType()) {\r
+ case HSSFCell.CELL_TYPE_BLANK: return "<blank>";\r
+ case HSSFCell.CELL_TYPE_BOOLEAN: return Boolean.toString(expecedCell.getBooleanCellValue());\r
+ case HSSFCell.CELL_TYPE_NUMERIC: return Double.toString(expecedCell.getNumericCellValue());\r
+ case HSSFCell.CELL_TYPE_STRING: return expecedCell.getRichStringCellValue().getString();\r
+ }\r
+ fail("Unexpected cell type of expected value (" + expecedCell.getCellType() + ")");\r
+ return "";\r
+ }\r
+\r
+\r
}\r
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests CODE() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestCodeFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- @Override\r
- protected String getFilename() {\r
- return "CodeFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestCodeFunctionsFromSpreadsheet.class, "CodeFunctionTestCaseData.xls");\r
}\r
}
\ No newline at end of file
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests COMPLEX() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestComplexFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- @Override\r
- protected String getFilename() {\r
- return "ComplexFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestComplexFunctionsFromSpreadsheet.class, "ComplexFunctionTestCaseData.xls");\r
}\r
}
\ No newline at end of file
==================================================================== */
package org.apache.poi.ss.formula.functions;
+import java.util.Collection;
+
+import org.junit.runners.Parameterized.Parameters;
+
/**
* Tests DGET() as loaded from a test data spreadsheet.
*/
public class TestDGetFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {
-
- protected String getFilename() {
- return "DGet.xls";
+ @Parameters(name="{0}")
+ public static Collection<Object[]> data() throws Exception {
+ return data(TestDGetFunctionsFromSpreadsheet.class, "DGet.xls");
}
}
==================================================================== */
package org.apache.poi.ss.formula.functions;
+import java.util.Collection;
+
+import org.junit.runners.Parameterized.Parameters;
+
/**
* Tests D*() functions as loaded from a test data spreadsheet.
*/
public class TestDStarFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {
-
- protected String getFilename() {
- return "DStar.xls";
+ @Parameters(name="{0}")
+ public static Collection<Object[]> data() throws Exception {
+ return data(TestDStarFunctionsFromSpreadsheet.class, "DStar.xls");
}
}
==================================================================== */\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
-* Tests DELTA() as loaded from a test data spreadsheet.<p/>\r
-*\r
-* @author cedric dot walter @ gmail dot com\r
-*/\r
+ * Tests DELTA() as loaded from a test data spreadsheet.<p/>\r
+ */\r
public class TestDeltaFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- protected String getFilename() {\r
- return "DeltaFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestDeltaFunctionsFromSpreadsheet.class, "DeltaFunctionTestCaseData.xls");\r
}\r
}\r
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests FactDouble() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestFactDoubleFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- protected String getFilename() {\r
- return "FactDoubleFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestFactDoubleFunctionsFromSpreadsheet.class, "FactDoubleFunctionTestCaseData.xls");\r
}\r
}\r
package org.apache.poi.ss.formula.functions;
+import java.util.Collection;
+
+import org.junit.runners.Parameterized.Parameters;
+
/**
* Tests FIXED() as loaded from a test data spreadsheet.
*/
public class TestFixedFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {
-
- @Override
- protected String getFilename() {
- return "57003-FixedFunctionTestCaseData.xls";
+ @Parameters(name="{0}")
+ public static Collection<Object[]> data() throws Exception {
+ return data(TestFixedFunctionsFromSpreadsheet.class, "57003-FixedFunctionTestCaseData.xls");
}
}
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests ImReal() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestImRealFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- protected String getFilename() {\r
- return "ImRealFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestImRealFunctionsFromSpreadsheet.class, "ImRealFunctionTestCaseData.xls");\r
}\r
}\r
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests Imaginary() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestImaginaryFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- protected String getFilename() {\r
- return "ImaginaryFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestImaginaryFunctionsFromSpreadsheet.class, "ImaginaryFunctionTestCaseData.xls");\r
}\r
}\r
package org.apache.poi.ss.formula.functions;
+import java.util.Collection;
+
+import org.junit.runners.Parameterized.Parameters;
+
/**
* Tests INDEX() as loaded from a test data spreadsheet.<p/>
*/
public final class TestIndexFunctionFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {
-
- @Override
- protected String getFilename() {
- return "IndexFunctionTestCaseData.xls";
+ @Parameters(name="{0}")
+ public static Collection<Object[]> data() throws Exception {
+ return data(TestIndexFunctionFromSpreadsheet.class, "IndexFunctionTestCaseData.xls");
}
}
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests INDIRECT() as loaded from a test data spreadsheet.<p/>\r
*\r
* more easily.\r
*/\r
public final class TestIndirectFunctionFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- @Override\r
- protected String getFilename() {\r
- return "IndirectFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestIndirectFunctionFromSpreadsheet.class, "IndirectFunctionTestCaseData.xls");\r
}\r
}\r
package org.apache.poi.ss.formula.functions;
+import java.util.Collection;
+import org.junit.runners.Parameterized.Parameters;
/**
* Tests lookup functions (VLOOKUP, HLOOKUP, LOOKUP, MATCH) as loaded from a test data spreadsheet.<p/>
* more easily.
*/
public final class TestLookupFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {
-
- @Override
- protected String getFilename() {
- return "LookupFunctionsTestCaseData.xls";
+ @Parameters(name="{0}")
+ public static Collection<Object[]> data() throws Exception {
+ return data(TestLookupFunctionsFromSpreadsheet.class, "LookupFunctionsTestCaseData.xls");
}
}
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
\r
+import org.junit.runners.Parameterized.Parameters;\r
\r
/**\r
* Tests Match functions as loaded from a test data spreadsheet.<p/>\r
* more easily.\r
*/\r
public final class TestMatchFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- @Override\r
- protected String getFilename() {\r
- return "MatchFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestMatchFunctionsFromSpreadsheet.class, "MatchFunctionTestCaseData.xls");\r
}\r
}\r
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests QUOTIENT() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestQuotientFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- @Override\r
- protected String getFilename() {\r
- return "QuotientFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestQuotientFunctionsFromSpreadsheet.class, "QuotientFunctionTestCaseData.xls");\r
}\r
}\r
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests REPT() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestReptFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- @Override\r
- protected String getFilename() {\r
- return "ReptFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestReptFunctionsFromSpreadsheet.class, "ReptFunctionTestCaseData.xls");\r
}\r
}
\ No newline at end of file
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests Roman() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestRomanFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- protected String getFilename() {\r
- return "RomanFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestRomanFunctionsFromSpreadsheet.class, "RomanFunctionTestCaseData.xls");\r
}\r
}\r
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests WeekNum() as loaded from a test data spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestWeekNumFunctionsFromSpreadsheet extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- protected String getFilename() {\r
- return "WeekNumFunctionTestCaseData.xls";\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
+ return data(TestWeekNumFunctionsFromSpreadsheet.class, "WeekNumFunctionTestCaseData.xls");\r
}\r
}\r
\r
package org.apache.poi.ss.formula.functions;\r
\r
+import java.util.Collection;\r
+\r
+import org.junit.runners.Parameterized.Parameters;\r
+\r
/**\r
* Tests WeekNum() as loaded from a test data 2013 excel spreadsheet.<p/>\r
- *\r
- * @author cedric dot walter @ gmail dot com\r
*/\r
public class TestWeekNumFunctionsFromSpreadsheet2013 extends BaseTestFunctionsFromSpreadsheet {\r
-\r
- protected String getFilename() {\r
+ @Parameters(name="{0}")\r
+ public static Collection<Object[]> data() throws Exception {\r
//Only open this file with Excel 2013 to keep binary specific to that version\r
- return "WeekNumFunctionTestCaseData2013.xls";\r
+ return data(TestWeekNumFunctionsFromSpreadsheet2013.class, "WeekNumFunctionTestCaseData2013.xls");\r
}\r
}\r
package org.apache.poi.ss.formula.ptg;
-import org.apache.poi.util.TempFile;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
import org.apache.poi.hssf.HSSFTestDataSamples;
import org.apache.poi.hssf.model.HSSFFormulaParser;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.CellValue;
+import org.junit.Test;
+
/**
* Tests for functions from external workbooks (e.g. YEARFRAC).
*/
-public final class TestExternalFunctionFormulas extends TestCase {
+public final class TestExternalFunctionFormulas {
/**
* tests <tt>NameXPtg.toFormulaString(Workbook)</tt> and logic in Workbook below that
*/
- public void testReadFormulaContainingExternalFunction() {
+ @Test
+ public void testReadFormulaContainingExternalFunction() throws Exception {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("externalFunctionExample.xls");
String expectedFormula = "YEARFRAC(B1,C1)";
HSSFSheet sht = wb.getSheetAt(0);
String cellFormula = sht.getRow(0).getCell(0).getCellFormula();
assertEquals(expectedFormula, cellFormula);
+
+ wb.close();
}
- public void testParse() {
+ @Test
+ public void testParse() throws Exception {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("externalFunctionExample.xls");
Ptg[] ptgs = HSSFFormulaParser.parse("YEARFRAC(B1,C1)", wb);
assertEquals(4, ptgs.length);
assertEquals(NameXPtg.class, ptgs[0].getClass());
wb.getSheetAt(0).getRow(0).createCell(6).setCellFormula("YEARFRAC(C1,B1)");
- if (false) {
- // In case you fancy checking in excel
- try {
- File tempFile = TempFile.createTempFile("testExtFunc", ".xls");
- FileOutputStream fout = new FileOutputStream(tempFile);
- wb.write(fout);
- fout.close();
- System.out.println("check out " + tempFile.getAbsolutePath());
- } catch (IOException e) {
- throw new RuntimeException(e);
- }
- }
+// if (false) {
+// // In case you fancy checking in excel
+// try {
+// File tempFile = TempFile.createTempFile("testExtFunc", ".xls");
+// FileOutputStream fout = new FileOutputStream(tempFile);
+// wb.write(fout);
+// fout.close();
+// System.out.println("check out " + tempFile.getAbsolutePath());
+// } catch (IOException e) {
+// throw new RuntimeException(e);
+// }
+// }
+ wb.close();
}
- public void testEvaluate() {
+ @Test
+ public void testEvaluate() throws Exception {
HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("externalFunctionExample.xls");
HSSFSheet sheet = wb.getSheetAt(0);
HSSFFormulaEvaluator fe = new HSSFFormulaEvaluator(wb);
confirmCellEval(sheet, 2, 0, fe, "YEARFRAC(B3,C3,D3)", 0.0);
confirmCellEval(sheet, 3, 0, fe, "IF(ISEVEN(3),1.2,1.6)", 1.6);
confirmCellEval(sheet, 4, 0, fe, "IF(ISODD(3),1.2,1.6)", 1.2);
+ wb.close();
}
private static void confirmCellEval(HSSFSheet sheet, int rowIx, int colIx,
package org.apache.poi.ss.usermodel;
-import junit.framework.TestCase;
-
import org.apache.poi.ss.ITestDataProvider;
import org.apache.poi.ss.usermodel.DataValidation.ErrorStyle;
import org.apache.poi.ss.usermodel.DataValidationConstraint.OperatorType;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.apache.poi.util.POILogFactory;
import org.apache.poi.util.POILogger;
+import org.junit.Test;
/**
* Class for testing Excel's data validation mechanism
*
* @author Dragos Buleandra ( dragos.buleandra@trade2b.ro )
*/
-public abstract class BaseTestDataValidation extends TestCase {
+public abstract class BaseTestDataValidation {
private final ITestDataProvider _testDataProvider;
private static final POILogger log = POILogFactory.getLogger(BaseTestDataValidation.class);
va.addValidation(OperatorType.LESS_OR_EQUAL, "4", null, ErrorStyle.STOP, "Less than or equal to 4", "-", false, true, false);
}
- public void testDataValidation() {
+ @Test
+ public void testDataValidation() throws Exception {
log("\nTest no. 2 - Test Excel's Data validation mechanism");
Workbook wb = _testDataProvider.createWorkbook();
WorkbookFormatter wf = new WorkbookFormatter(wb);
addCustomValidations(wf);
log("done !");
- wb = _testDataProvider.writeOutAndReadBack(wb);
+ _testDataProvider.writeOutAndReadBack(wb).close();
+
+ wb.close();
}
package org.apache.poi.ss.usermodel;
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
import org.apache.poi.ss.ITestDataProvider;
import org.apache.poi.ss.util.AreaReference;
import org.apache.poi.ss.util.CellReference;
+import org.junit.Test;
/**
* Tests of implementations of {@link org.apache.poi.ss.usermodel.Name}.
*
* @author Yegor Kozlov
*/
-public abstract class BaseTestNamedRange extends TestCase {
+public abstract class BaseTestNamedRange {
private final ITestDataProvider _testDataProvider;
_testDataProvider = testDataProvider;
}
- public final void testCreate(){
+ @Test
+ public final void testCreate() throws Exception {
// Create a new workbook
Workbook wb = _testDataProvider.createWorkbook();
- Sheet sheet1 = wb.createSheet("Test1");
- Sheet sheet2 = wb.createSheet("Testing Named Ranges");
+ wb.createSheet("Test1");
+ wb.createSheet("Testing Named Ranges");
Name name1 = wb.createName();
name1.setNameName("testOne");
// expected during successful test
}
}
+
+ wb.close();
}
- public final void testUnicodeNamedRange() {
- Workbook workBook = _testDataProvider.createWorkbook();
- workBook.createSheet("Test");
- Name name = workBook.createName();
+ @Test
+ public final void testUnicodeNamedRange() throws Exception {
+ Workbook wb1 = _testDataProvider.createWorkbook();
+ wb1.createSheet("Test");
+ Name name = wb1.createName();
name.setNameName("\u03B1");
name.setRefersToFormula("Test!$D$3:$E$8");
- Workbook workBook2 = _testDataProvider.writeOutAndReadBack(workBook);
- Name name2 = workBook2.getNameAt(0);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ Name name2 = wb2.getNameAt(0);
assertEquals("\u03B1", name2.getNameName());
assertEquals("Test!$D$3:$E$8", name2.getRefersToFormula());
+
+ wb2.close();
+ wb1.close();
}
- public final void testAddRemove() {
+ @Test
+ public final void testAddRemove() throws Exception {
Workbook wb = _testDataProvider.createWorkbook();
assertEquals(0, wb.getNumberOfNames());
Name name1 = wb.createName();
wb.removeName(0);
assertEquals(1, wb.getNumberOfNames());
+
+ wb.close();
}
- public final void testScope() {
+ @Test
+ public final void testScope() throws Exception {
Workbook wb = _testDataProvider.createWorkbook();
wb.createSheet();
wb.createSheet();
if("aaa".equals(wb.getNameAt(i).getNameName())) cnt++;
}
assertEquals(3, cnt);
+
+ wb.close();
}
/**
* <p>
* Addresses Bug <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=13775" target="_bug">#13775</a>
*/
- public final void testMultiNamedRange() {
+ @Test
+ public final void testMultiNamedRange() throws Exception {
// Create a new workbook
- Workbook wb = _testDataProvider.createWorkbook();
+ Workbook wb1 = _testDataProvider.createWorkbook();
// Create a worksheet 'sheet1' in the new workbook
- wb.createSheet ();
- wb.setSheetName (0, "sheet1");
+ wb1.createSheet ();
+ wb1.setSheetName (0, "sheet1");
// Create another worksheet 'sheet2' in the new workbook
- wb.createSheet ();
- wb.setSheetName (1, "sheet2");
+ wb1.createSheet ();
+ wb1.setSheetName (1, "sheet2");
// Create a new named range for worksheet 'sheet1'
- Name namedRange1 = wb.createName();
+ Name namedRange1 = wb1.createName();
// Set the name for the named range for worksheet 'sheet1'
namedRange1.setNameName("RangeTest1");
namedRange1.setRefersToFormula("sheet1" + "!$A$1:$L$41");
// Create a new named range for worksheet 'sheet2'
- Name namedRange2 = wb.createName();
+ Name namedRange2 = wb1.createName();
// Set the name for the named range for worksheet 'sheet2'
namedRange2.setNameName("RangeTest2");
// Write the workbook to a file
// Read the Excel file and verify its content
- wb = _testDataProvider.writeOutAndReadBack(wb);
- Name nm1 =wb.getNameAt(wb.getNameIndex("RangeTest1"));
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ Name nm1 = wb2.getNameAt(wb2.getNameIndex("RangeTest1"));
assertTrue("Name is "+nm1.getNameName(),"RangeTest1".equals(nm1.getNameName()));
- assertTrue("Reference is "+nm1.getRefersToFormula(),(wb.getSheetName(0)+"!$A$1:$L$41").equals(nm1.getRefersToFormula()));
+ assertTrue("Reference is "+nm1.getRefersToFormula(),(wb2.getSheetName(0)+"!$A$1:$L$41").equals(nm1.getRefersToFormula()));
- Name nm2 =wb.getNameAt(wb.getNameIndex("RangeTest2"));
+ Name nm2 = wb2.getNameAt(wb2.getNameIndex("RangeTest2"));
assertTrue("Name is "+nm2.getNameName(),"RangeTest2".equals(nm2.getNameName()));
- assertTrue("Reference is "+nm2.getRefersToFormula(),(wb.getSheetName(1)+"!$A$1:$O$21").equals(nm2.getRefersToFormula()));
+ assertTrue("Reference is "+nm2.getRefersToFormula(),(wb2.getSheetName(1)+"!$A$1:$O$21").equals(nm2.getRefersToFormula()));
+
+ wb2.close();
+ wb1.close();
}
/**
* Test to see if the print areas can be retrieved/created in memory
*/
- public final void testSinglePrintArea() {
+ @Test
+ public final void testSinglePrintArea() throws Exception {
Workbook workbook = _testDataProvider.createWorkbook();
workbook.createSheet("Test Print Area");
String sheetName = workbook.getSheetName(0);
assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
assertEquals("'" + sheetName + "'!$A$1:$B$1", retrievedPrintArea);
+
+ workbook.close();
}
/**
* For Convenience, don't force sheet names to be used
*/
- public final void testSinglePrintAreaWOSheet()
+ @Test
+ public final void testSinglePrintAreaWOSheet() throws Exception
{
Workbook workbook = _testDataProvider.createWorkbook();
workbook.createSheet("Test Print Area");
assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
assertEquals("'" + sheetName + "'!" + reference, retrievedPrintArea);
+
+ workbook.close();
}
/**
* Test to see if the print area made it to the file
*/
- public final void testPrintAreaFile() {
- Workbook workbook = _testDataProvider.createWorkbook();
- workbook.createSheet("Test Print Area");
- String sheetName = workbook.getSheetName(0);
+ @Test
+ public final void testPrintAreaFile() throws Exception {
+ Workbook wb1 = _testDataProvider.createWorkbook();
+ wb1.createSheet("Test Print Area");
+ String sheetName = wb1.getSheetName(0);
String reference = "$A$1:$B$1";
- workbook.setPrintArea(0, reference);
+ wb1.setPrintArea(0, reference);
- workbook = _testDataProvider.writeOutAndReadBack(workbook);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
- String retrievedPrintArea = workbook.getPrintArea(0);
+ String retrievedPrintArea = wb2.getPrintArea(0);
assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
assertEquals("References Match", "'" + sheetName + "'!$A$1:$B$1", retrievedPrintArea);
+
+ wb2.close();
+ wb1.close();
}
/**
* Test to see if multiple print areas made it to the file
*/
- public final void testMultiplePrintAreaFile() {
- Workbook workbook = _testDataProvider.createWorkbook();
+ @Test
+ public final void testMultiplePrintAreaFile() throws Exception {
+ Workbook wb1 = _testDataProvider.createWorkbook();
- workbook.createSheet("Sheet1");
- workbook.createSheet("Sheet2");
- workbook.createSheet("Sheet3");
+ wb1.createSheet("Sheet1");
+ wb1.createSheet("Sheet2");
+ wb1.createSheet("Sheet3");
String reference1 = "$A$1:$B$1";
String reference2 = "$B$2:$D$5";
String reference3 = "$D$2:$F$5";
- workbook.setPrintArea(0, reference1);
- workbook.setPrintArea(1, reference2);
- workbook.setPrintArea(2, reference3);
+ wb1.setPrintArea(0, reference1);
+ wb1.setPrintArea(1, reference2);
+ wb1.setPrintArea(2, reference3);
//Check created print areas
String retrievedPrintArea;
- retrievedPrintArea = workbook.getPrintArea(0);
+ retrievedPrintArea = wb1.getPrintArea(0);
assertNotNull("Print Area Not Found (Sheet 1)", retrievedPrintArea);
assertEquals("Sheet1!" + reference1, retrievedPrintArea);
- retrievedPrintArea = workbook.getPrintArea(1);
+ retrievedPrintArea = wb1.getPrintArea(1);
assertNotNull("Print Area Not Found (Sheet 2)", retrievedPrintArea);
assertEquals("Sheet2!" + reference2, retrievedPrintArea);
- retrievedPrintArea = workbook.getPrintArea(2);
+ retrievedPrintArea = wb1.getPrintArea(2);
assertNotNull("Print Area Not Found (Sheet 3)", retrievedPrintArea);
assertEquals("Sheet3!" + reference3, retrievedPrintArea);
// Check print areas after re-reading workbook
- workbook = _testDataProvider.writeOutAndReadBack(workbook);
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
- retrievedPrintArea = workbook.getPrintArea(0);
+ retrievedPrintArea = wb2.getPrintArea(0);
assertNotNull("Print Area Not Found (Sheet 1)", retrievedPrintArea);
assertEquals("Sheet1!" + reference1, retrievedPrintArea);
- retrievedPrintArea = workbook.getPrintArea(1);
+ retrievedPrintArea = wb2.getPrintArea(1);
assertNotNull("Print Area Not Found (Sheet 2)", retrievedPrintArea);
assertEquals("Sheet2!" + reference2, retrievedPrintArea);
- retrievedPrintArea = workbook.getPrintArea(2);
+ retrievedPrintArea = wb2.getPrintArea(2);
assertNotNull("Print Area Not Found (Sheet 3)", retrievedPrintArea);
assertEquals("Sheet3!" + reference3, retrievedPrintArea);
+
+ wb2.close();
+ wb1.close();
}
/**
* Tests the setting of print areas with coordinates (Row/Column designations)
*
*/
- public final void testPrintAreaCoords(){
+ @Test
+ public final void testPrintAreaCoords() throws Exception {
Workbook workbook = _testDataProvider.createWorkbook();
workbook.createSheet("Test Print Area");
String sheetName = workbook.getSheetName(0);
assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
assertEquals("'" + sheetName + "'!$A$1:$B$1", retrievedPrintArea);
+
+ workbook.close();
}
* Tests the parsing of union area expressions, and re-display in the presence of sheet names
* with special characters.
*/
- public final void testPrintAreaUnion(){
+ @Test
+ public final void testPrintAreaUnion() throws Exception {
Workbook workbook = _testDataProvider.createWorkbook();
workbook.createSheet("Test Print Area");
String retrievedPrintArea = workbook.getPrintArea(0);
assertNotNull("Print Area not defined for first sheet", retrievedPrintArea);
assertEquals("'Test Print Area'!$A$1:$B$1,'Test Print Area'!$D$1:$F$2", retrievedPrintArea);
+
+ workbook.close();
}
/**
* Verifies an existing print area is deleted
*
*/
- public final void testPrintAreaRemove() {
+ @Test
+ public final void testPrintAreaRemove() throws Exception {
Workbook workbook = _testDataProvider.createWorkbook();
workbook.createSheet("Test Print Area");
workbook.getSheetName(0);
workbook.removePrintArea(0);
assertNull("PrintArea was not removed", workbook.getPrintArea(0));
+ workbook.close();
}
/**
* Test that multiple named ranges can be added written and read
*/
- public final void testMultipleNamedWrite() {
- Workbook wb = _testDataProvider.createWorkbook();
+ @Test
+ public final void testMultipleNamedWrite() throws Exception {
+ Workbook wb1 = _testDataProvider.createWorkbook();
- wb.createSheet("testSheet1");
- String sheetName = wb.getSheetName(0);
+ wb1.createSheet("testSheet1");
+ String sheetName = wb1.getSheetName(0);
assertEquals("testSheet1", sheetName);
//Creating new Named Range
- Name newNamedRange = wb.createName();
+ Name newNamedRange = wb1.createName();
newNamedRange.setNameName("RangeTest");
newNamedRange.setRefersToFormula(sheetName + "!$D$4:$E$8");
//Creating another new Named Range
- Name newNamedRange2 = wb.createName();
+ Name newNamedRange2 = wb1.createName();
newNamedRange2.setNameName("AnotherTest");
newNamedRange2.setRefersToFormula(sheetName + "!$F$1:$G$6");
- wb.getNameAt(0);
+ wb1.getNameAt(0);
- wb = _testDataProvider.writeOutAndReadBack(wb);
- Name nm =wb.getNameAt(wb.getNameIndex("RangeTest"));
+ Workbook wb2 = _testDataProvider.writeOutAndReadBack(wb1);
+ Name nm =wb2.getNameAt(wb2.getNameIndex("RangeTest"));
assertTrue("Name is "+nm.getNameName(),"RangeTest".equals(nm.getNameName()));
- assertTrue("Reference is "+nm.getRefersToFormula(),(wb.getSheetName(0)+"!$D$4:$E$8").equals(nm.getRefersToFormula()));
+ assertTrue("Reference is "+nm.getRefersToFormula(),(wb2.getSheetName(0)+"!$D$4:$E$8").equals(nm.getRefersToFormula()));
- nm = wb.getNameAt(wb.getNameIndex("AnotherTest"));
+ nm = wb2.getNameAt(wb2.getNameIndex("AnotherTest"));
assertTrue("Name is "+nm.getNameName(),"AnotherTest".equals(nm.getNameName()));
assertTrue("Reference is "+nm.getRefersToFormula(),newNamedRange2.getRefersToFormula().equals(nm.getRefersToFormula()));
+
+ wb2.close();
+ wb1.close();
}
/**
* Verifies correct functioning for "single cell named range" (aka "named cell")
*/
- public final void testNamedCell_1() {
+ @Test
+ public final void testNamedCell_1() throws Exception {
// setup for this testcase
String sheetName = "Test Named Cell";
assertNotNull(aNamedCell);
// retrieve the cell at the named range and test its contents
+ @SuppressWarnings("deprecation")
AreaReference aref = new AreaReference(aNamedCell.getRefersToFormula());
assertTrue("Should be exactly 1 cell in the named cell :'" +cellName+"'", aref.isSingleCell());
Cell c = r.getCell(cref.getCol());
String contents = c.getRichStringCellValue().getString();
assertEquals("Contents of cell retrieved by its named reference", contents, cellValue);
+
+ wb.close();
}
/**
* Verifies correct functioning for "single cell named range" (aka "named cell")
*/
- public final void testNamedCell_2() {
+ @Test
+ public final void testNamedCell_2() throws Exception {
// setup for this testcase
String sname = "TestSheet", cname = "TestName", cvalue = "TestVal";
CellReference cref = new CellReference(aNamedCell.getRefersToFormula());
assertNotNull(cref);
Sheet s = wb.getSheet(cref.getSheetName());
+ assertNotNull(s);
Row r = sheet.getRow(cref.getRow());
Cell c = r.getCell(cref.getCol());
String contents = c.getRichStringCellValue().getString();
assertEquals("Contents of cell retrieved by its named reference", contents, cvalue);
+
+ wb.close();
}
* could do the same, but that would involve adjusting subsequent name indexes across
* all formulas. <p/>
*
- * For the moment, POI has been made to behave more sensibly with uninitialised name
+ * For the moment, POI has been made to behave more sensibly with uninitialized name
* records.
*/
- public final void testUninitialisedNameGetRefersToFormula_bug46973() {
+ @Test
+ public final void testUninitialisedNameGetRefersToFormula_bug46973() throws Exception {
Workbook wb = _testDataProvider.createWorkbook();
Name n = wb.createName();
n.setNameName("UPSState");
- String formula;
- try {
- formula = n.getRefersToFormula();
- } catch (IllegalArgumentException e) {
- if (e.getMessage().equals("ptgs must not be null")) {
- throw new AssertionFailedError("Identified bug 46973");
- }
- throw e;
- }
+ String formula = n.getRefersToFormula();
+
+ // bug 46973: fails here with IllegalArgumentException
+ // ptgs must not be null
+
assertNull(formula);
- assertFalse(n.isDeleted()); // according to exact definition of isDeleted()
+ // according to exact definition of isDeleted()
+ assertFalse(n.isDeleted());
+ wb.close();
}
- public final void testDeletedCell() {
+ @Test
+ public final void testDeletedCell() throws Exception {
Workbook wb = _testDataProvider.createWorkbook();
Name n = wb.createName();
n.setNameName("MyName");
// contrived example to expose bug:
n.setRefersToFormula("if(A1,\"#REF!\", \"\")");
- if (n.isDeleted()) {
- throw new AssertionFailedError("Identified bug in recoginising formulas referring to deleted cells");
- }
-
+ assertFalse("Identified bug in recoginising formulas referring to deleted cells", n.isDeleted());
+
+ wb.close();
}
- public final void testFunctionNames() {
+ @Test
+ public final void testFunctionNames() throws Exception {
Workbook wb = _testDataProvider.createWorkbook();
Name n = wb.createName();
assertFalse(n.isFunctionName());
n.setFunction(false);
assertFalse(n.isFunctionName());
+
+ wb.close();
}
- public final void testDefferedSetting() {
+ @Test
+ public final void testDefferedSetting() throws Exception {
Workbook wb = _testDataProvider.createWorkbook();
Name n1 = wb.createName();
assertNull(n1.getRefersToFormula());
} catch(Exception e){
assertEquals("The workbook already contains this name: sale_1", e.getMessage());
}
-
+
+ wb.close();
}
}
row.createCell(5).setCellFormula(matchExpr);
row.createCell(6).setCellFormula(jmExpr.replaceAll("'", "\""));
- if (false) {
- // for observing arithmetic near numeric range boundaries
- row.createCell(7).setCellFormula(cel0ref + " * 1.0001");
- row.createCell(8).setCellFormula(cel0ref + " / 1.0001");
- }
+// if (false) {
+// // for observing arithmetic near numeric range boundaries
+// row.createCell(7).setCellFormula(cel0ref + " * 1.0001");
+// row.createCell(8).setCellFormula(cel0ref + " / 1.0001");
+// }
}
private static String formatLongAsHex(long l) {
bb[i+2] = (byte) (val >> 16);
bb[i+1] = (byte) (val >> 8);
bb[i+0] = (byte) (val >> 0);
- if (false) {
- String newVal = interpretLong(bb, i);
- System.out.println("changed offset " + i + " from " + oldVal + " to " + newVal);
- }
+// if (false) {
+// String newVal = interpretLong(bb, i);
+// System.out.println("changed offset " + i + " from " + oldVal + " to " + newVal);
+// }
}
projects / poi.git / commitdiff