Merged revisions 638786-638802,638805-638811,638813-638814,638816-639230,639233-639241,639243-639253,639255-639486,639488-639601,639603-639835,639837-639917,639919-640056,640058-640710,640712-641156,641158-641184,641186-641795,641797-641798,641800-641933,641935-641963,641965-641966,641968-641995,641997-642230,642232-642562,642564-642565,642568-642570,642572-642573,642576-642736,642739-642877,642879,642881-642890,642892-642903,642905-642945,642947-643624,643626-643653,643655-643669,643671,643673-643830,643832-643833,643835-644342,644344-644472,644474-644508,644510-645347,645349-645351,645353-645559,645561-645565,645568-645951,645953-646193,646195-646311,646313-646404,646406-646665,646667-646853,646855-646869,646871-647151,647153-647185,647187-647277,647279-647566,647568-647573,647575,647578-647711,647714-647737,647739-647823,647825-648155,648157-648202,648204-648273,648275,648277-648302,648304-648333,648335-648588,648590-648622,648625-648673,648675-649141,649144,649146-649556,649558-649795,649799,649801-649910,649912-649913,649915-650128,650131-650132,650134-650137,650140-650914,650916-651991,651993-652284,652286-652287,652289,652291,652293-652297,652299-652328,652330-652425,652427-652445,652447-652560,652562-652933,652935,652937-652993,652995-653116,653118-653124,653126-653483,653487-653519,653522-653550,653552-653607,653609-653667,653669-653674,653676-653814,653817-653830,653832-653891,653893-653944,653946-654055,654057-654355,654357-654365,654367-654648,654651-655215,655217-655277,655279-655281,655283-655911,655913-656212,656214,656216-656251,656253-656698,656700-656756,656758-656892,656894-657135,657137-657165,657168-657179,657181-657354,657356-657357,657359-657701,657703-657874,657876-658032,658034-658284,658286,658288-658301,658303-658307,658309-658321,658323-658335,658337-658348,658351,658353-658832,658834-658983,658985,658987-659066,659068-659402,659404-659428,659430-659451,659453-659454,659456-659461,659463-659477,659479-659524,659526-659571,659574,659576-660255,660257-660262,660264-660279,660281-660343,660345-660473,660475-660827,660829-660833,660835-660888,660890-663321,663323-663435,663437-663764,663766-663854,663856-664219,664221-664489,664494-664514,664516-668013,668015-668142,668144-668152,668154,668156-668256,668258,668260-669139,669141-669455,669457-669657,669659-669808,669810-670189,670191-671321,671323-672229,672231-672549,672551-672552,672554-672561,672563-672566,672568,672571-673049,673051-673852,673854-673862,673864-673986,673988-673996,673998-674347,674349-674890,674892-674910,674912-674936,674938-674952,674954-675078,675080-675085,675087-675217,675219-675660,675662-675670,675672-675716,675718-675726,675728-675733,675735-675775,675777-675782,675784,675786-675791,675794-675852,675854-676200,676202,676204,676206-676220,676222-676309,676311-676456,676458-676994,676996-677027,677030-677040,677042-677056,677058-677375,677377-677968,677970-677971,677973,677975-677994,677996-678286,678288-678538,678540-680393,680395-680469,680471-680529,680531-680852,680854-681529,681531-681571,681573-682224,682226,682228,682231-682281,682283-682335,682337-682507,682509,682512-682517,682519-682532,682534-682619,682622-682777,682779-682998,683000-683019,683021-683022,683024-683080,683082-683092,683094-683095,683097-683127,683129-683131,683133-683166,683168-683698,683700-683705,683707-683757,683759-683787,683789-683870,683872-683879,683881-683900,683902-684066,684068-684074,684076-684222,684224-684254,684257-684281,684283-684286,684288-684292,684294-684298,684300-684301,684303-684308,684310-684317,684320,684323-684335,684337-684348,684350-684354,684356-684361,684363-684369,684371-684453,684455-684883,684885-684937,684940-684958,684960-684970,684972-684985,684987-685053,685055-685063,685065-685259,685261-685262,685264-685266,685268-685282,685285-686035,686037-686045,686047-686052,686054-686206,686208-686215,686217-686277,686279-686289,686291-686620,686622-686623,686626-686627,686629-686639,686641-686843,686845-686976,686978-689430 via svnmerge from

https://svn.apache.org/repos/asf/poi/trunk

........
  r687403 | nick | 2008-08-20 19:14:11 +0100 (Wed, 20 Aug 2008) | 1 line
  
  Make an initial start on hpbf code
........
  r687423 | nick | 2008-08-20 19:50:15 +0100 (Wed, 20 Aug 2008) | 1 line
  
  More HPBF stuff, and some tests
........
  r687429 | nick | 2008-08-20 20:40:05 +0100 (Wed, 20 Aug 2008) | 1 line
  
  Quill CONTENTS bits, and tests
........
  r687443 | nick | 2008-08-20 21:13:08 +0100 (Wed, 20 Aug 2008) | 1 line
  
  HPBF text extractor and unit tests
........
  r688426 | josh | 2008-08-23 23:47:51 +0100 (Sat, 23 Aug 2008) | 1 line
  
  Fix for bug 45672 - prevent MissingRecordAwareHSSFListener generating multiple LastCellOfRowDummyRecords when shared formulas are present
........
  r688642 | josh | 2008-08-25 08:56:37 +0100 (Mon, 25 Aug 2008) | 1 line
  
  JDK 1.4 fixes for new hpbf stuff. Some clean-up
........
  r688650 | josh | 2008-08-25 09:09:02 +0100 (Mon, 25 Aug 2008) | 1 line
  
  Initial support for evaluating external add-in functions like YEARFRAC
........
  r688655 | josh | 2008-08-25 09:30:54 +0100 (Mon, 25 Aug 2008) | 1 line
  
  Fix for bug 45682 - allow cloning of sheets with conditional formatting
........
  r688825 | josh | 2008-08-25 19:57:14 +0100 (Mon, 25 Aug 2008) | 1 line
  
  Fix for small bug introduced in c688655 - keep header field in sync with number of rules
........
  r688910 | josh | 2008-08-25 23:41:08 +0100 (Mon, 25 Aug 2008) | 1 line
  
  Replaced calls to deprecated versions of createCell(), getCell(), createRow(), and getRow(). (Changing short to int)
........


git-svn-id: https://svn.apache.org/repos/asf/poi/branches/ooxml@689435 13f79535-47bb-0310-9956-ffa450edef68

src/contrib/src/org/apache/poi/hssf/usermodel/contrib/HSSFCellUtil.java

@@ -113,7 +113,7 @@ public final class HSSFCellUtil
 
         if ( cell == null )
         {
-            cell = row.createCell( (short)column );
+            cell = row.createCell(column );
         }
         return cell;
     }

src/documentation/content/xdocs/changes.xml

@@ -64,6 +64,9 @@
            <action dev="POI-DEVELOPERS" type="add">Created a common interface for handling Excel files, irrespective of if they are .xls or .xlsx</action>
         </release>
         <release version="3.1.1-alpha1" date="2008-??-??">
+           <action dev="POI-DEVELOPERS" type="fix">45682 - Fix for cloning of CFRecordsAggregate</action>
+           <action dev="POI-DEVELOPERS" type="add">Initial support for evaluating external add-in functions like YEARFRAC</action>
+           <action dev="POI-DEVELOPERS" type="fix">45672 - Fix for MissingRecordAwareHSSFListener to prevent multiple LastCellOfRowDummyRecords when shared formulas are present</action>
            <action dev="POI-DEVELOPERS" type="fix">45645 - Fix for HSSFSheet.autoSizeColumn() for widths exceeding Short.MAX_VALUE</action>
            <action dev="POI-DEVELOPERS" type="add">45623 - Support for additional HSSF header and footer fields, including bold and full file path</action>
            <action dev="POI-DEVELOPERS" type="add">45623 - Support stripping HSSF header and footer fields (eg page number) out of header and footer text if required</action>

src/documentation/content/xdocs/status.xml

@@ -61,6 +61,9 @@
            <action dev="POI-DEVELOPERS" type="add">Created a common interface for handling Excel files, irrespective of if they are .xls or .xlsx</action>
         </release>
         <release version="3.1.1-alpha1" date="2008-??-??">
+           <action dev="POI-DEVELOPERS" type="fix">45682 - Fix for cloning of CFRecordsAggregate</action>
+           <action dev="POI-DEVELOPERS" type="add">Initial support for evaluating external add-in functions like YEARFRAC</action>
+           <action dev="POI-DEVELOPERS" type="fix">45672 - Fix for MissingRecordAwareHSSFListener to prevent multiple LastCellOfRowDummyRecords when shared formulas are present</action>
            <action dev="POI-DEVELOPERS" type="fix">45645 - Fix for HSSFSheet.autoSizeColumn() for widths exceeding Short.MAX_VALUE</action>
            <action dev="POI-DEVELOPERS" type="add">45623 - Support for additional HSSF header and footer fields, including bold and full file path</action>
            <action dev="POI-DEVELOPERS" type="add">45623 - Support stripping HSSF header and footer fields (eg page number) out of header and footer text if required</action>

src/java/org/apache/poi/hssf/dev/HSSF.java

@@ -132,7 +132,7 @@ public class HSSF
                 {
                     c.setCellStyle(cs);
                 }
-                c = r.createCell(( short ) (cellnum + 1),
+                c = r.createCell(cellnum + 1,
                                  HSSFCell.CELL_TYPE_STRING);
                 c.setCellValue(new HSSFRichTextString("TEST"));
                 s.setColumnWidth(( short ) (cellnum + 1),
@@ -347,7 +347,7 @@ public class HSSF
                     sheet.removeRow(row);
                 }
                 HSSFRow  row  = sheet.getRow(39);
-                HSSFCell cell = row.getCell(( short ) 3);
+                HSSFCell cell = row.getCell(3);
 
                 cell.setCellType(HSSFCell.CELL_TYPE_STRING);
                 cell.setCellValue("MODIFIED CELL!!!!!");

src/java/org/apache/poi/hssf/eventusermodel/MissingRecordAwareHSSFListener.java

@@ -17,22 +17,15 @@
 
 package org.apache.poi.hssf.eventusermodel;
 
-import org.apache.poi.hssf.eventusermodel.HSSFListener;
 import org.apache.poi.hssf.eventusermodel.dummyrecord.LastCellOfRowDummyRecord;
 import org.apache.poi.hssf.eventusermodel.dummyrecord.MissingCellDummyRecord;
 import org.apache.poi.hssf.eventusermodel.dummyrecord.MissingRowDummyRecord;
 import org.apache.poi.hssf.record.BOFRecord;
-import org.apache.poi.hssf.record.BlankRecord;
+import org.apache.poi.hssf.record.CellValueRecordInterface;
-import org.apache.poi.hssf.record.BoolErrRecord;
-import org.apache.poi.hssf.record.BoundSheetRecord;
-import org.apache.poi.hssf.record.FormulaRecord;
-import org.apache.poi.hssf.record.LabelRecord;
-import org.apache.poi.hssf.record.LabelSSTRecord;
 import org.apache.poi.hssf.record.NoteRecord;
-import org.apache.poi.hssf.record.NumberRecord;
-import org.apache.poi.hssf.record.RKRecord;
 import org.apache.poi.hssf.record.Record;
 import org.apache.poi.hssf.record.RowRecord;
+import org.apache.poi.hssf.record.SharedFormulaRecord;
 
 /**
  * <p>A HSSFListener which tracks rows and columns, and will
@@ -44,16 +37,16 @@ import org.apache.poi.hssf.record.RowRecord;
  *  file, or was skipped from being written as it was
  *  blank.
  */
-public class MissingRecordAwareHSSFListener implements HSSFListener {
+public final class MissingRecordAwareHSSFListener implements HSSFListener {
 	private HSSFListener childListener;
 	
 	// Need to have different counters for cell rows and
 	//  row rows, as you sometimes get a RowRecord in the
 	//  middle of some cells, and that'd break everything
-	private int lastRowRow = -1;
+	private int lastRowRow;
 	
-	private int lastCellRow = -1;
+	private int lastCellRow;
-	private int lastCellColumn = -1;
+	private int lastCellColumn;
 	
 	/**
 	 * Constructs a new MissingRecordAwareHSSFListener, which
@@ -62,128 +55,80 @@ public class MissingRecordAwareHSSFListener implements HSSFListener {
 	 * @param listener The HSSFListener to pass records on to
 	 */
 	public MissingRecordAwareHSSFListener(HSSFListener listener) {
+		resetCounts();
 		childListener = listener;
 	}
 
 	public void processRecord(Record record) {
-		int thisRow = -1;
+		int thisRow;
-		int thisColumn = -1;
+		int thisColumn;
-		
+
-		switch (record.getSid())
+
-        {
+		if (record instanceof CellValueRecordInterface) {
-            // the BOFRecord can represent either the beginning of a sheet or the workbook
+			CellValueRecordInterface valueRec = (CellValueRecordInterface) record;
-            case BOFRecord.sid:
+			thisRow = valueRec.getRow();
-                BOFRecord bof = (BOFRecord) record;
+			thisColumn = valueRec.getColumn();
-                if (bof.getType() == bof.TYPE_WORKBOOK)
+		} else {
-                {
+			thisRow = -1;
-                	// Reset the row and column counts - new workbook
+			thisColumn = -1;
-                	lastRowRow = -1;
+
-                	lastCellRow = -1;
+			switch (record.getSid()) {
-                	lastCellColumn = -1;
+				// the BOFRecord can represent either the beginning of a sheet or
-                    //System.out.println("Encountered workbook");
+				// the workbook
-                } else if (bof.getType() == bof.TYPE_WORKSHEET)
+				case BOFRecord.sid:
-                {
+					BOFRecord bof = (BOFRecord) record;
-                	// Reset the row and column counts - new sheet
+					if (bof.getType() == bof.TYPE_WORKBOOK || bof.getType() == bof.TYPE_WORKSHEET) {
-                	lastRowRow = -1;
+						// Reset the row and column counts - new workbook / worksheet
-                	lastCellRow = -1;
+						resetCounts();
-                	lastCellColumn = -1;
+					}
-                    //System.out.println("Encountered sheet reference");
+					break;
-                }
+				case RowRecord.sid:
-                break;
+					RowRecord rowrec = (RowRecord) record;
-            case BoundSheetRecord.sid:
+					//System.out.println("Row " + rowrec.getRowNumber() + " found, first column at "
-                BoundSheetRecord bsr = (BoundSheetRecord) record;
+					//        + rowrec.getFirstCol() + " last column at " + rowrec.getLastCol());
-                //System.out.println("New sheet named: " + bsr.getSheetname());
+
-                break;
+					// If there's a jump in rows, fire off missing row records
-            case RowRecord.sid:
+					if (lastRowRow + 1 < rowrec.getRowNumber()) {
-                RowRecord rowrec = (RowRecord) record;
+						for (int i = (lastRowRow + 1); i < rowrec.getRowNumber(); i++) {
-                //System.out.println("Row " + rowrec.getRowNumber() + " found, first column at "
+							MissingRowDummyRecord dr = new MissingRowDummyRecord(i);
-                //        + rowrec.getFirstCol() + " last column at " + rowrec.getLastCol());
+							childListener.processRecord(dr);
-                
+						}
-                // If there's a jump in rows, fire off missing row records
+					}
-                if(lastRowRow+1 < rowrec.getRowNumber()) {
+
-                	for(int i=(lastRowRow+1); i<rowrec.getRowNumber(); i++) {
+					// Record this as the last row we saw
-                		MissingRowDummyRecord dr = new MissingRowDummyRecord(i);
+					lastRowRow = rowrec.getRowNumber();
-                		childListener.processRecord(dr);
+					break;
-                	}
+
-                }
+				case SharedFormulaRecord.sid:
-                
+					// SharedFormulaRecord occurs after the first FormulaRecord of the cell range.
-                // Record this as the last row we saw
+					// There are probably (but not always) more cell records after this
-                lastRowRow = rowrec.getRowNumber();
+					// - so don't fire off the LastCellOfRowDummyRecord yet
-                break;
+					childListener.processRecord(record);
-                
+					return;
-                
+				case NoteRecord.sid:
-            // These are all the "cell" records
+					NoteRecord nrec = (NoteRecord) record;
-                
+					thisRow = nrec.getRow();
-            case BlankRecord.sid:
+					thisColumn = nrec.getColumn();
-            	BlankRecord brec = (BlankRecord) record;
+					break;
-                thisRow = brec.getRow();
+			}
-                thisColumn = brec.getColumn();
+		}
-                break;
-            case BoolErrRecord.sid:
-            	BoolErrRecord berec = (BoolErrRecord) record;
-                thisRow = berec.getRow();
-                thisColumn = berec.getColumn();
-                break;
-            case FormulaRecord.sid:
-            	FormulaRecord frec = (FormulaRecord) record;
-            	thisRow = frec.getRow();
-            	thisColumn = frec.getColumn();
-                break;
-            case LabelRecord.sid:
-            	LabelRecord lrec = (LabelRecord) record;
-                thisRow = lrec.getRow();
-                thisColumn = lrec.getColumn();
-                //System.out.println("Cell found containing String "
-                //        + " at row " + lrec.getRow() + " and column " + lrec.getColumn());
-                break;
-            case LabelSSTRecord.sid:
-            	LabelSSTRecord lsrec = (LabelSSTRecord) record;
-                thisRow = lsrec.getRow();
-                thisColumn = lsrec.getColumn();
-                //System.out.println("Cell found containing String "
-                //        + " at row " + lsrec.getRow() + " and column " + lsrec.getColumn());
-                break;
-            case NoteRecord.sid:
-            	NoteRecord nrec = (NoteRecord) record;
-            	thisRow = nrec.getRow();
-            	thisColumn = nrec.getColumn();
-                break;
-            case NumberRecord.sid:
-                NumberRecord numrec = (NumberRecord) record;
-                thisRow = numrec.getRow();
-                thisColumn = numrec.getColumn();
-                //System.out.println("Cell found with value " + numrec.getValue()
-                //        + " at row " + numrec.getRow() + " and column " + numrec.getColumn());
-                break;
-            case RKRecord.sid:
-            	RKRecord rkrec = (RKRecord) record;
-            	thisRow = rkrec.getRow();
-            	thisColumn = rkrec.getColumn();
-                break;
-            default:
-            	//System.out.println(record.getClass());
-            	break;
-        }
-		
 		// If we're on cells, and this cell isn't in the same
 		//  row as the last one, then fire the 
-		//  dummy end-of-row records?
+		//  dummy end-of-row records
 		if(thisRow != lastCellRow && lastCellRow > -1) {
 			for(int i=lastCellRow; i<thisRow; i++) {
 				int cols = -1;
 				if(i == lastCellRow) {
 					cols = lastCellColumn;
 				}
-				LastCellOfRowDummyRecord r = new LastCellOfRowDummyRecord(i, cols);
+				childListener.processRecord(new LastCellOfRowDummyRecord(i, cols));
-				childListener.processRecord(r);
 			}
 		}
 		
 		// If we've just finished with the cells, then fire the
-		//  final dummy end-of-row record
+		// final dummy end-of-row record
 		if(lastCellRow != -1 && lastCellColumn != -1 && thisRow == -1) {
-			LastCellOfRowDummyRecord r = new LastCellOfRowDummyRecord(lastCellRow, lastCellColumn);
+			childListener.processRecord(new LastCellOfRowDummyRecord(lastCellRow, lastCellColumn));
-			childListener.processRecord(r);
 			
 			lastCellRow = -1;
 			lastCellColumn = -1;
@@ -196,11 +141,10 @@ public class MissingRecordAwareHSSFListener implements HSSFListener {
 		}
 		
 		// If there's a gap in the cells, then fire
-		//  the dummy cell records?
+		//  the dummy cell records
-		if(lastCellColumn != (thisColumn-1)) {
+		if(lastCellColumn != thisColumn-1) {
 			for(int i=lastCellColumn+1; i<thisColumn; i++) {
-				MissingCellDummyRecord r = new MissingCellDummyRecord(thisRow, i);
+				childListener.processRecord(new MissingCellDummyRecord(thisRow, i));
-				childListener.processRecord(r);
 			}
 		}
 		
@@ -209,7 +153,13 @@ public class MissingRecordAwareHSSFListener implements HSSFListener {
 			lastCellColumn = thisColumn;
 			lastCellRow = thisRow;
 		}
-		
+
 		childListener.processRecord(record);
 	}
+
+	private void resetCounts() {
+		lastRowRow = -1;
+		lastCellRow = -1;
+		lastCellColumn = -1;
+	}
 }

src/java/org/apache/poi/hssf/extractor/ExcelExtractor.java

@@ -107,7 +107,7 @@ public class ExcelExtractor extends POIOLE2TextExtractor implements org.apache.p
 				int firstCell = row.getFirstCellNum();
 				int lastCell = row.getLastCellNum();
 				for(int k=firstCell;k<lastCell;k++) {
-					HSSFCell cell = row.getCell((short)k);
+					HSSFCell cell = row.getCell(k);
 					boolean outputContents = false;
 					if(cell == null) { continue; }
 					

src/java/org/apache/poi/hssf/record/CFHeaderRecord.java

@@ -40,11 +40,11 @@ public final class CFHeaderRecord extends Record {
 	{
 		field_4_cell_ranges = new CellRangeAddressList();
 	}
-	public CFHeaderRecord(CellRangeAddress[] regions)
+	public CFHeaderRecord(CellRangeAddress[] regions, int nRules) {
-	{
 		CellRangeAddress[] unmergedRanges = regions;
 		CellRangeAddress[] mergeCellRanges = CellRangeUtil.mergeCellRanges(unmergedRanges);
 		setCellRanges(mergeCellRanges);
+		field_1_numcf = nRules;
 	}
 
 	public CFHeaderRecord(RecordInputStream in)

src/java/org/apache/poi/hssf/record/SupBookRecord.java

@@ -150,6 +150,7 @@ public final class SupBookRecord extends Record {
             sb.append("Internal References ");
             sb.append(" nSheets= ").append(field_1_number_of_sheets);
         }
+        sb.append("]");
         return sb.toString();
     }
     private int getDataSize() {

src/java/org/apache/poi/hssf/record/aggregates/CFRecordsAggregate.java

@@ -18,14 +18,12 @@
 package org.apache.poi.hssf.record.aggregates;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
 import org.apache.poi.hssf.model.RecordStream;
 import org.apache.poi.hssf.record.CFHeaderRecord;
 import org.apache.poi.hssf.record.CFRuleRecord;
 import org.apache.poi.hssf.record.Record;
-import org.apache.poi.hssf.record.RecordInputStream;
 import org.apache.poi.ss.util.Region;
 import org.apache.poi.ss.util.CellRangeAddress;
 
@@ -37,12 +35,10 @@ import org.apache.poi.ss.util.CellRangeAddress;
  * @author Dmitriy Kumshayev
  *
  */
-public final class CFRecordsAggregate extends Record {
+public final class CFRecordsAggregate extends RecordAggregate {
 	/** Excel allows up to 3 conditional formating rules */
 	private static final int MAX_CONDTIONAL_FORMAT_RULES = 3;
 
-	public final static short sid = -2008; // not a real BIFF record
-
 	private final CFHeaderRecord header;
 
 	/** List of CFRuleRecord objects */
@@ -59,6 +55,9 @@ public final class CFRecordsAggregate extends Record {
 			throw new IllegalArgumentException("No more than " 
 					+ MAX_CONDTIONAL_FORMAT_RULES + " rules may be specified");
 		}
+		if (pRules.length != pHeader.getNumberOfConditionalFormats()) {
+			throw new RuntimeException("Mismatch number of rules");
+		}
 		header = pHeader;
 		rules = new ArrayList(3);
 		for (int i = 0; i < pRules.length; i++) {
@@ -67,7 +66,7 @@ public final class CFRecordsAggregate extends Record {
 	}
 
 	public CFRecordsAggregate(CellRangeAddress[] regions, CFRuleRecord[] rules) {
-		this(new CFHeaderRecord(regions), rules);
+		this(new CFHeaderRecord(regions, rules.length), rules);
 	}
 
 	/**
@@ -108,45 +107,6 @@ public final class CFRecordsAggregate extends Record {
 		return new CFRecordsAggregate((CFHeaderRecord) header.clone(), newRecs);
 	}
 
-	protected void fillFields(RecordInputStream in)
-	{
-	     // You never fill an aggregate record
-	}
-
-	public short getSid()
-	{
-		return sid;
-	}
-
-	/**
-	 * called by the class that is responsible for writing this sucker.
-	 * Subclasses should implement this so that their data is passed back in a
-	 * byte array.
-	 *
-	 * @param offset to begin writing at
-	 * @param data byte array containing instance data
-	 * @return number of bytes written
-	 */
-
-	public int serialize(int offset, byte[] data)
-	{
-		int nRules = rules.size();
-		header.setNumberOfConditionalFormats(nRules);
-
-		int pos = offset;
-
-		pos += header.serialize(pos, data);
-		for(int i=0; i< nRules; i++) {
-			pos += getRule(i).serialize(pos, data);
-		}
-		return pos - offset;
-	}
-
-	protected void validateSid(short id)
-	{
-		// do nothing here
-	}
-
 	/**
 	 * @return the header. Never <code>null</code>.
 	 */
@@ -166,10 +126,16 @@ public final class CFRecordsAggregate extends Record {
 		return (CFRuleRecord) rules.get(idx);
 	}
 	public void setRule(int idx, CFRuleRecord r) {
+		if (r == null) {
+			throw new IllegalArgumentException("r must not be null");
+		}
 		checkRuleIndex(idx);
 		rules.set(idx, r);
 	}
 	public void addRule(CFRuleRecord r) {
+		if (r == null) {
+			throw new IllegalArgumentException("r must not be null");
+		}
 		if(rules.size() >= MAX_CONDTIONAL_FORMAT_RULES) {
 			throw new IllegalStateException("Cannot have more than " 
 					+ MAX_CONDTIONAL_FORMAT_RULES + " conditional format rules");
@@ -181,26 +147,6 @@ public final class CFRecordsAggregate extends Record {
 		return rules.size();
 	}
 
-	/**
-	 *  @return sum of sizes of all aggregated records
-	 */
-	public int getRecordSize() 
-	{
-		int size = 0;
-		if( header != null)
-		{
-			size += header.getRecordSize();
-		}
-		if( rules != null)
-		{
-			for(Iterator irecs = rules.iterator(); irecs.hasNext(); )
-			{
-				size += (( Record ) irecs.next()).getRecordSize();
-			}
-		}
-		return size;
-	}
-
 	/**
 	 * String representation of CFRecordsAggregate
 	 */
@@ -216,12 +162,17 @@ public final class CFRecordsAggregate extends Record {
 		for(int i=0; i<rules.size(); i++)
 		{
 			CFRuleRecord cfRule = (CFRuleRecord)rules.get(i);
-			if(cfRule!=null)
+			buffer.append(cfRule.toString());
-			{
-				buffer.append(cfRule.toString());
-			}
 		}
 		buffer.append("[/CF]\n");
 		return buffer.toString();
 	}
+
+	public void visitContainedRecords(RecordVisitor rv) {
+		rv.visitRecord(header);
+		for(int i=0; i<rules.size(); i++) {
+			CFRuleRecord rule = (CFRuleRecord)rules.get(i);
+			rv.visitRecord(rule);
+		}
+	}
 }

src/java/org/apache/poi/hssf/record/aggregates/ConditionalFormattingTable.java

@@ -22,7 +22,6 @@ import java.util.List;
 
 import org.apache.poi.hssf.model.RecordStream;
 import org.apache.poi.hssf.record.CFHeaderRecord;
-import org.apache.poi.hssf.record.Record;
 
 /**
  * Holds all the conditional formatting for a workbook sheet.<p/>
@@ -53,7 +52,8 @@ public final class ConditionalFormattingTable extends RecordAggregate {
 
 	public void visitContainedRecords(RecordVisitor rv) {
 		for (int i = 0; i < _cfHeaders.size(); i++) {
-			rv.visitRecord((Record) _cfHeaders.get(i));
+			CFRecordsAggregate subAgg = (CFRecordsAggregate) _cfHeaders.get(i);
+			subAgg.visitContainedRecords(rv);
 		}
 	}
 

src/java/org/apache/poi/hssf/record/formula/NameXPtg.java

@@ -30,11 +30,11 @@ public final class NameXPtg extends OperandPtg {
 	private final static int SIZE = 7;
 
 	/** index to REF entry in externsheet record */
-	private int _sheetRefIndex;
+	private final int _sheetRefIndex;
 	/** index to defined name or externname table(1 based) */
-	private int _nameNumber;
+	private final int _nameNumber;
 	/** reserved must be 0 */
-	private int _reserved;
+	private final int _reserved;
 
 	private NameXPtg(int sheetRefIndex, int nameNumber, int reserved) {
 		_sheetRefIndex = sheetRefIndex;
@@ -73,4 +73,11 @@ public final class NameXPtg extends OperandPtg {
 	public byte getDefaultOperandClass() {
 		return Ptg.CLASS_VALUE;
 	}
+
+	public int getSheetRefIndex() {
+		return _sheetRefIndex;
+	}
+	public int getNameIndex() {
+		return _nameNumber - 1;
+	}
 }

src/java/org/apache/poi/hssf/record/formula/atp/AnalysisToolPak.java

@@ -0,0 +1,154 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hssf.record.formula.atp;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.poi.hssf.record.formula.eval.ErrorEval;
+import org.apache.poi.hssf.record.formula.eval.Eval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
+import org.apache.poi.hssf.record.formula.functions.FreeRefFunction;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+
+public final class AnalysisToolPak {
+
+	private static final FreeRefFunction NotImplemented = new FreeRefFunction() {
+
+		public ValueEval evaluate(Eval[] args, int srcCellRow, short srcCellCol,
+				Workbook workbook, Sheet sheet) {
+			return ErrorEval.FUNCTION_NOT_IMPLEMENTED;
+		}
+	};
+	
+	private static Map _functionsByName = createFunctionsMap();
+
+	private AnalysisToolPak() {
+		// no instances of this class
+	}
+
+	public static FreeRefFunction findFunction(String name) {
+		return (FreeRefFunction)_functionsByName.get(name);
+	}
+	
+	private static Map createFunctionsMap() {
+		Map m = new HashMap(100);
+
+		r(m, "ACCRINT", null);
+		r(m, "ACCRINTM", null);
+		r(m, "AMORDEGRC", null);
+		r(m, "AMORLINC", null);
+		r(m, "BESSELI", null);
+		r(m, "BESSELJ", null);
+		r(m, "BESSELK", null);
+		r(m, "BESSELY", null);
+		r(m, "BIN2DEC", null);
+		r(m, "BIN2HEX", null);
+		r(m, "BIN2OCT", null);
+		r(m, "CO MPLEX", null);
+		r(m, "CONVERT", null);
+		r(m, "COUPDAYBS", null);
+		r(m, "COUPDAYS", null);
+		r(m, "COUPDAYSNC", null);
+		r(m, "COUPNCD", null);
+		r(m, "COUPNUM", null);
+		r(m, "COUPPCD", null);
+		r(m, "CUMIPMT", null);
+		r(m, "CUMPRINC", null);
+		r(m, "DEC2BIN", null);
+		r(m, "DEC2HEX", null);
+		r(m, "DEC2OCT", null);
+		r(m, "DELTA", null);
+		r(m, "DISC", null);
+		r(m, "DOLLARDE", null);
+		r(m, "DOLLARFR", null);
+		r(m, "DURATION", null);
+		r(m, "EDATE", null);
+		r(m, "EFFECT", null);
+		r(m, "EOMONTH", null);
+		r(m, "ERF", null);
+		r(m, "ERFC", null);
+		r(m, "FACTDOUBLE", null);
+		r(m, "FVSCHEDULE", null);
+		r(m, "GCD", null);
+		r(m, "GESTEP", null);
+		r(m, "HEX2BIN", null);
+		r(m, "HEX2DEC", null);
+		r(m, "HEX2OCT", null);
+		r(m, "IMABS", null);
+		r(m, "IMAGINARY", null);
+		r(m, "IMARGUMENT", null);
+		r(m, "IMCONJUGATE", null);
+		r(m, "IMCOS", null);
+		r(m, "IMDIV", null);
+		r(m, "IMEXP", null);
+		r(m, "IMLN", null);
+		r(m, "IMLOG10", null);
+		r(m, "IMLOG2", null);
+		r(m, "IMPOWER", null);
+		r(m, "IMPRODUCT", null);
+		r(m, "IMREAL", null);
+		r(m, "IMSIN", null);
+		r(m, "IMSQRT", null);
+		r(m, "IMSUB", null);
+		r(m, "IMSUM", null);
+		r(m, "INTRATE", null);
+		r(m, "ISEVEN", null);
+		r(m, "ISODD", null);
+		r(m, "LCM", null);
+		r(m, "MDURATION", null);
+		r(m, "MROUND", null);
+		r(m, "MULTINOMIAL", null);
+		r(m, "NETWORKDAYS", null);
+		r(m, "NOMINAL", null);
+		r(m, "OCT2BIN", null);
+		r(m, "OCT2DEC", null);
+		r(m, "OCT2HEX", null);
+		r(m, "ODDFPRICE", null);
+		r(m, "ODDFYIELD", null);
+		r(m, "ODDLPRICE", null);
+		r(m, "ODDLYIELD", null);
+		r(m, "PRICE", null);
+		r(m, "PRICEDISC", null);
+		r(m, "PRICEMAT", null);
+		r(m, "QUOTIENT", null);
+		r(m, "RAND BETWEEN", null);
+		r(m, "RECEIVED", null);
+		r(m, "SERIESSUM", null);
+		r(m, "SQRTPI", null);
+		r(m, "TBILLEQ", null);
+		r(m, "TBILLPRICE", null);
+		r(m, "TBILLYIELD", null);
+		r(m, "WEEKNUM", null);
+		r(m, "WORKDAY", null);
+		r(m, "XIRR", null);
+		r(m, "XNPV", null);
+		r(m, "YEARFRAC", YearFrac.instance);
+		r(m, "YIELD", null);
+		r(m, "YIELDDISC", null);
+		r(m, "YIELDMAT", null);
+		
+		return m;
+	}
+
+	private static void r(Map m, String functionName, FreeRefFunction pFunc) {
+		FreeRefFunction func = pFunc == null ? NotImplemented : pFunc;
+		m.put(functionName, func);
+	}
+}

src/java/org/apache/poi/hssf/record/formula/atp/YearFrac.java

@@ -0,0 +1,160 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hssf.record.formula.atp;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.regex.Pattern;
+
+import org.apache.poi.hssf.record.formula.eval.ErrorEval;
+import org.apache.poi.hssf.record.formula.eval.Eval;
+import org.apache.poi.hssf.record.formula.eval.EvaluationException;
+import org.apache.poi.hssf.record.formula.eval.NumberEval;
+import org.apache.poi.hssf.record.formula.eval.OperandResolver;
+import org.apache.poi.hssf.record.formula.eval.StringEval;
+import org.apache.poi.hssf.record.formula.eval.ValueEval;
+import org.apache.poi.hssf.record.formula.functions.FreeRefFunction;
+import org.apache.poi.ss.usermodel.DateUtil;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+/**
+ * Implementation of Excel 'Analysis ToolPak' function YEARFRAC()<br/>
+ * 
+ * Returns the fraction of the year spanned by two dates.<p/>
+ * 
+ * <b>Syntax</b><br/>
+ * <b>YEARFRAC</b>(<b>startDate</b>, <b>endDate</b>, basis)<p/>
+ * 
+ * The <b>basis</b> optionally specifies the behaviour of YEARFRAC as follows:
+ * 
+ * <table border="0" cellpadding="1" cellspacing="0" summary="basis parameter description">
+ *   <tr><th>Value</th><th>Days per Month</th><th>Days per Year</th></tr>
+ *   <tr align='center'><td>0 (default)</td><td>30</td><td>360</td></tr>
+ *   <tr align='center'><td>1</td><td>actual</td><td>actual</td></tr>
+ *   <tr align='center'><td>2</td><td>actual</td><td>360</td></tr>
+ *   <tr align='center'><td>3</td><td>actual</td><td>365</td></tr>
+ *   <tr align='center'><td>4</td><td>30</td><td>360</td></tr>
+ * </table>
+ * 
+ */
+final class YearFrac implements FreeRefFunction {
+
+	public static final FreeRefFunction instance = new YearFrac();
+	
+	private YearFrac() {
+		// enforce singleton
+	}
+
+	public ValueEval evaluate(Eval[] args, int srcCellRow, short srcCellCol, Workbook workbook,
+			Sheet sheet) {
+
+		double result;
+		try {
+			int basis = 0; // default
+			switch(args.length) {
+				case 3:
+					basis = evaluateIntArg(args[2], srcCellRow, srcCellCol);
+				case 2:
+					break;
+				default:
+					return ErrorEval.VALUE_INVALID;  
+			}
+			double startDateVal = evaluateDateArg(args[0], srcCellRow, srcCellCol);
+			double endDateVal = evaluateDateArg(args[1], srcCellRow, srcCellCol);
+			result = YearFracCalculator.calculate(startDateVal, endDateVal, basis);
+		} catch (EvaluationException e) {
+			return e.getErrorEval();
+		}
+		
+		return new NumberEval(result);
+	}
+
+	private static double evaluateDateArg(Eval arg, int srcCellRow, short srcCellCol) throws EvaluationException {
+		ValueEval ve = OperandResolver.getSingleValue(arg, srcCellRow, srcCellCol);
+
+		if (ve instanceof StringEval) {
+			String strVal = ((StringEval) ve).getStringValue();
+			Double dVal = OperandResolver.parseDouble(strVal);
+			if (dVal != null) {
+				return dVal.doubleValue();
+			}
+			Calendar date = parseDate(strVal);
+			return DateUtil.getExcelDate(date, false);
+		}
+		return OperandResolver.coerceValueToDouble(ve);
+	}
+
+	private static Calendar parseDate(String strVal) throws EvaluationException {
+		String[] parts = Pattern.compile("/").split(strVal);
+		if (parts.length != 3) {
+			throw new EvaluationException(ErrorEval.VALUE_INVALID);
+		}
+		String part2 = parts[2];
+		int spacePos = part2.indexOf(' ');
+		if (spacePos > 0) {
+			// drop time portion if present
+			part2 = part2.substring(0, spacePos);
+		}
+		int f0;
+		int f1;
+		int f2;
+		try {
+			f0 = Integer.parseInt(parts[0]);
+			f1 = Integer.parseInt(parts[1]);
+			f2 = Integer.parseInt(part2);
+		} catch (NumberFormatException e) {
+			throw new EvaluationException(ErrorEval.VALUE_INVALID);
+		}
+		if (f0<0 || f1<0 || f2<0 || f0>12 || f1>12 || f2>12) {
+			// easy to see this cannot be a valid date
+			throw new EvaluationException(ErrorEval.VALUE_INVALID);
+		}
+		
+		if (f0 >= 1900 && f0 < 9999) {
+			// when 4 digit value appears first, the format is YYYY/MM/DD, regardless of OS settings
+			return makeDate(f0, f1, f2);
+		}
+		// otherwise the format seems to depend on OS settings (default date format)
+		if (false) {
+			// MM/DD/YYYY is probably a good guess, if the in the US
+			return makeDate(f2, f0, f1);
+		}
+		// TODO - find a way to choose the correct date format
+		throw new RuntimeException("Unable to determine date format for text '" + strVal + "'");
+	}
+
+	/**
+	 * @param month 1-based
+	 */
+	private static Calendar makeDate(int year, int month, int day) throws EvaluationException {
+		if (month < 1 || month > 12) {
+			throw new EvaluationException(ErrorEval.VALUE_INVALID);
+		}
+		Calendar cal = new GregorianCalendar(year, month-1, 1, 0, 0, 0);
+		cal.set(Calendar.MILLISECOND, 0);
+		if (day <1 || day>cal.getActualMaximum(Calendar.DAY_OF_MONTH)) {
+			throw new EvaluationException(ErrorEval.VALUE_INVALID);
+		}
+		return cal;
+	}
+
+	private static int evaluateIntArg(Eval arg, int srcCellRow, short srcCellCol) throws EvaluationException {
+		ValueEval ve = OperandResolver.getSingleValue(arg, srcCellRow, srcCellCol);
+		return OperandResolver.coerceValueToInt(ve);
+	}
+}

src/java/org/apache/poi/hssf/record/formula/atp/YearFracCalculator.java

@@ -0,0 +1,344 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hssf.record.formula.atp;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.TimeZone;
+
+import org.apache.poi.hssf.record.formula.eval.ErrorEval;
+import org.apache.poi.hssf.record.formula.eval.EvaluationException;
+import org.apache.poi.hssf.usermodel.HSSFDateUtil;
+
+
+/**
+ * Internal calculation methods for Excel 'Analysis ToolPak' function YEARFRAC()<br/>
+ *  
+ * Algorithm inspired by www.dwheeler.com/yearfrac
+ * 
+ * @author Josh Micich
+ */
+final class YearFracCalculator {
+	/** use UTC time-zone to avoid daylight savings issues */
+	private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone("UTC");
+	private static final int MS_PER_HOUR = 60 * 60 * 1000;
+	private static final int MS_PER_DAY = 24 * MS_PER_HOUR;
+	private static final int DAYS_PER_NORMAL_YEAR = 365;
+	private static final int DAYS_PER_LEAP_YEAR = DAYS_PER_NORMAL_YEAR + 1;
+
+	/** the length of normal long months i.e. 31 */
+	private static final int LONG_MONTH_LEN = 31;
+	/** the length of normal short months i.e. 30 */
+	private static final int SHORT_MONTH_LEN = 30;
+	private static final int SHORT_FEB_LEN = 28;
+	private static final int LONG_FEB_LEN = SHORT_FEB_LEN + 1;
+
+	private YearFracCalculator() {
+		// no instances of this class
+	}
+
+
+	public static double calculate(double pStartDateVal, double pEndDateVal, int basis) throws EvaluationException {
+
+		if (basis < 0 || basis >= 5) {
+			// if basis is invalid the result is #NUM!
+			throw new EvaluationException(ErrorEval.NUM_ERROR);
+		}
+
+		// common logic for all bases
+
+		// truncate day values
+		int startDateVal = (int) Math.floor(pStartDateVal);
+		int endDateVal = (int) Math.floor(pEndDateVal);
+		if (startDateVal == endDateVal) {
+			// when dates are equal, result is zero 
+			return 0;
+		}
+		// swap start and end if out of order
+		if (startDateVal > endDateVal) {
+			int temp = startDateVal;
+			startDateVal = endDateVal;
+			endDateVal = temp;
+		}
+
+		switch (basis) {
+			case 0: return basis0(startDateVal, endDateVal);
+			case 1: return basis1(startDateVal, endDateVal);
+			case 2: return basis2(startDateVal, endDateVal);
+			case 3: return basis3(startDateVal, endDateVal);
+			case 4: return basis4(startDateVal, endDateVal);
+		}
+		throw new IllegalStateException("cannot happen");
+	}
+
+
+	/**
+	 * @param startDateVal assumed to be less than or equal to endDateVal
+	 * @param endDateVal assumed to be greater than or equal to startDateVal
+	 */
+	public static double basis0(int startDateVal, int endDateVal) {
+		SimpleDate startDate = createDate(startDateVal);
+		SimpleDate endDate = createDate(endDateVal);
+		int date1day = startDate.day;
+		int date2day = endDate.day;
+
+		// basis zero has funny adjustments to the day-of-month fields when at end-of-month 
+		if (date1day == LONG_MONTH_LEN && date2day == LONG_MONTH_LEN) {
+			date1day = SHORT_MONTH_LEN;
+			date2day = SHORT_MONTH_LEN;
+		} else if (date1day == LONG_MONTH_LEN) {
+			date1day = SHORT_MONTH_LEN;
+		} else if (date1day == SHORT_MONTH_LEN && date2day == LONG_MONTH_LEN) {
+			date2day = SHORT_MONTH_LEN;
+			// Note: If date2day==31, it STAYS 31 if date1day < 30.
+			// Special fixes for February:
+		} else if (startDate.month == 2 && isLastDayOfMonth(startDate)) {
+			// Note - these assignments deliberately set Feb 30 date.
+			date1day = SHORT_MONTH_LEN;
+			if (endDate.month == 2 && isLastDayOfMonth(endDate)) {
+				// only adjusted when first date is last day in Feb
+				date2day = SHORT_MONTH_LEN;
+			}
+		}
+		return calculateAdjusted(startDate, endDate, date1day, date2day);
+	}
+	/**
+	 * @param startDateVal assumed to be less than or equal to endDateVal
+	 * @param endDateVal assumed to be greater than or equal to startDateVal
+	 */
+	public static double basis1(int startDateVal, int endDateVal) {
+		SimpleDate startDate = createDate(startDateVal);
+		SimpleDate endDate = createDate(endDateVal);
+		double yearLength;
+		if (isGreaterThanOneYear(startDate, endDate)) {
+			yearLength = averageYearLength(startDate.year, endDate.year);
+		} else if (shouldCountFeb29(startDate, endDate)) {
+			yearLength = DAYS_PER_LEAP_YEAR;
+		} else {
+			yearLength = DAYS_PER_NORMAL_YEAR;
+		}
+		return dateDiff(startDate.tsMilliseconds, endDate.tsMilliseconds) / yearLength;
+	}
+
+	/**
+	 * @param startDateVal assumed to be less than or equal to endDateVal
+	 * @param endDateVal assumed to be greater than or equal to startDateVal
+	 */
+	public static double basis2(int startDateVal, int endDateVal) {
+		return (endDateVal - startDateVal) / 360.0;
+	}
+	/**
+	 * @param startDateVal assumed to be less than or equal to endDateVal
+	 * @param endDateVal assumed to be greater than or equal to startDateVal
+	 */
+	public static double basis3(double startDateVal, double endDateVal) {
+		return (endDateVal - startDateVal) / 365.0;
+	}
+	/**
+	 * @param startDateVal assumed to be less than or equal to endDateVal
+	 * @param endDateVal assumed to be greater than or equal to startDateVal
+	 */
+	public static double basis4(int startDateVal, int endDateVal) {
+		SimpleDate startDate = createDate(startDateVal);
+		SimpleDate endDate = createDate(endDateVal);
+		int date1day = startDate.day;
+		int date2day = endDate.day;
+
+
+		// basis four has funny adjustments to the day-of-month fields when at end-of-month 
+		if (date1day == LONG_MONTH_LEN) {
+			date1day = SHORT_MONTH_LEN;
+		}
+		if (date2day == LONG_MONTH_LEN) {
+			date2day = SHORT_MONTH_LEN;
+		}
+		// Note - no adjustments for end of Feb
+		return calculateAdjusted(startDate, endDate, date1day, date2day);
+	}
+
+
+	private static double calculateAdjusted(SimpleDate startDate, SimpleDate endDate, int date1day,
+			int date2day) {
+		double dayCount 
+			= (endDate.year - startDate.year) * 360
+			+ (endDate.month - startDate.month) * SHORT_MONTH_LEN
+			+ (date2day - date1day) * 1;
+		return dayCount / 360;
+	}
+
+	private static boolean isLastDayOfMonth(SimpleDate date) {
+		if (date.day < SHORT_FEB_LEN) {
+			return false;
+		}
+		return date.day == getLastDayOfMonth(date);
+	}
+
+	private static int getLastDayOfMonth(SimpleDate date) {
+		switch (date.month) {
+			case 1:
+			case 3:
+			case 5:
+			case 7:
+			case 8:
+			case 10:
+			case 12:
+				return LONG_MONTH_LEN;
+			case 4:
+			case 6:
+			case 9:
+			case 11:
+				return SHORT_MONTH_LEN;
+		}
+		if (isLeapYear(date.year)) {
+			return LONG_FEB_LEN;
+		}
+		return SHORT_FEB_LEN;
+	}
+
+	/**
+	 * Assumes dates are no more than 1 year apart.
+	 * @return <code>true</code> if dates both within a leap year, or span a period including Feb 29
+	 */
+	private static boolean shouldCountFeb29(SimpleDate start, SimpleDate end) {
+		boolean startIsLeapYear = isLeapYear(start.year);
+		if (startIsLeapYear && start.year == end.year) {
+			// note - dates may not actually span Feb-29, but it gets counted anyway in this case
+			return true;
+		}
+
+		boolean endIsLeapYear = isLeapYear(end.year);
+		if (!startIsLeapYear && !endIsLeapYear) {
+			return false;
+		}
+		if (startIsLeapYear) {
+			switch (start.month) {
+				case SimpleDate.JANUARY:
+				case SimpleDate.FEBRUARY:
+					return true;
+			}
+			return false;
+		}
+		if (endIsLeapYear) {
+			switch (end.month) {
+				case SimpleDate.JANUARY:
+					return false;
+				case SimpleDate.FEBRUARY:
+					break;
+				default:
+					return true;
+			}
+			return end.day == LONG_FEB_LEN;
+		}
+		return false;
+	}
+
+	/**
+	 * @return the whole number of days between the two time-stamps.  Both time-stamps are
+	 * assumed to represent 12:00 midnight on the respective day.
+	 */
+	private static int dateDiff(long startDateMS, long endDateMS) {
+		long msDiff = endDateMS - startDateMS;
+
+		// some extra checks to make sure we don't hide some other bug with the rounding 
+		int remainderHours = (int) ((msDiff % MS_PER_DAY) / MS_PER_HOUR);
+		switch (remainderHours) {
+			case 0:  // normal case
+				break;
+			case 1:  // transition from normal time to daylight savings adjusted
+			case 23: // transition from daylight savings adjusted to normal time
+				// Unexpected since we are using UTC_TIME_ZONE 
+			default:
+				throw new RuntimeException("Unexpected date diff between " + startDateMS + " and " + endDateMS);
+
+		}
+		return (int) (0.5 + ((double)msDiff / MS_PER_DAY));
+	}
+
+	private static double averageYearLength(int startYear, int endYear) {
+		int dayCount = 0;
+		for (int i=startYear; i<=endYear; i++) {
+			dayCount += DAYS_PER_NORMAL_YEAR;
+			if (isLeapYear(i)) {
+				dayCount++;
+			}
+		}
+		double numberOfYears = endYear-startYear+1;
+		return dayCount / numberOfYears;
+	}
+
+	private static boolean isLeapYear(int i) {
+		// leap years are always divisible by 4
+		if (i % 4 != 0) {
+			return false;
+		}
+		// each 4th century is a leap year
+		if (i % 400 == 0) {
+			return true;
+		}
+		// all other centuries are *not* leap years
+		if (i % 100 == 0) {
+			return false;
+		}
+		return true;
+	}
+
+	private static boolean isGreaterThanOneYear(SimpleDate start, SimpleDate end) {
+		if (start.year == end.year) {
+			return false;
+		}
+		if (start.year + 1 != end.year) {
+			return true;
+		}
+
+		if (start.month > end.month) {
+			return false;
+		}
+		if (start.month < end.month) {
+			return true;
+		}
+
+		return start.day < end.day;
+	}
+
+	private static SimpleDate createDate(int dayCount) {
+		GregorianCalendar calendar = new GregorianCalendar(UTC_TIME_ZONE);
+		HSSFDateUtil.setCalendar(calendar, dayCount, 0, false);
+		return new SimpleDate(calendar);
+	}
+
+	private static final class SimpleDate {
+
+		public static final int JANUARY = 1;
+		public static final int FEBRUARY = 2;
+
+		public final int year;
+		/** 1-based month */
+		public final int month;
+		/** day of month */
+		public final int day;
+		/** milliseconds since 1970 */
+		public long tsMilliseconds;
+
+		public SimpleDate(Calendar cal) {
+			year = cal.get(Calendar.YEAR);
+			month = cal.get(Calendar.MONTH) + 1;
+			day = cal.get(Calendar.DAY_OF_MONTH);
+			tsMilliseconds = cal.getTimeInMillis();
+		}
+	}
+}

src/java/org/apache/poi/hssf/record/formula/eval/ExternalFunction.java

@@ -17,14 +17,16 @@
 
 package org.apache.poi.hssf.record.formula.eval;
 
+import org.apache.poi.hssf.record.formula.atp.AnalysisToolPak;
 import org.apache.poi.hssf.record.formula.functions.FreeRefFunction;
 import org.apache.poi.ss.usermodel.Sheet;
 import org.apache.poi.ss.usermodel.Workbook;
 /**
  * 
- * Common entry point for all external functions (where 
+ * Common entry point for all user-defined (non-built-in) functions (where 
  * <tt>AbstractFunctionPtg.field_2_fnc_index</tt> == 255)
  * 
+ * TODO rename to UserDefinedFunction
  * @author Josh Micich
  */
 final class ExternalFunction implements FreeRefFunction {
@@ -36,27 +38,43 @@ final class ExternalFunction implements FreeRefFunction {
 			throw new RuntimeException("function name argument missing");
 		}
 		
-		if (!(args[0] instanceof NameEval)) {
+		Eval nameArg = args[0];
-			throw new RuntimeException("First argument should be a NameEval, but got ("
-					+ args[0].getClass().getName() + ")");
-		}
-		NameEval functionNameEval = (NameEval) args[0];
-		
-		int nOutGoingArgs = nIncomingArgs -1;
-		Eval[] outGoingArgs = new Eval[nOutGoingArgs];
-		System.arraycopy(args, 1, outGoingArgs, 0, nOutGoingArgs);
-		
 		FreeRefFunction targetFunc;
 		try {
-			targetFunc = findTargetFunction(workbook, functionNameEval);
+			if (nameArg instanceof NameEval) {
+				targetFunc = findInternalUserDefinedFunction(workbook, (NameEval) nameArg);
+			} else if (nameArg instanceof NameXEval) {
+				targetFunc = findExternalUserDefinedFunction(workbook, (NameXEval) nameArg);
+			} else {
+				throw new RuntimeException("First argument should be a NameEval, but got ("
+						+ nameArg.getClass().getName() + ")");
+			}
 		} catch (EvaluationException e) {
 			return e.getErrorEval();
 		}
-		
+		int nOutGoingArgs = nIncomingArgs -1;
+		Eval[] outGoingArgs = new Eval[nOutGoingArgs];
+		System.arraycopy(args, 1, outGoingArgs, 0, nOutGoingArgs);
 		return targetFunc.evaluate(outGoingArgs, srcCellRow, srcCellCol, workbook, sheet);
 	}
 
-	private FreeRefFunction findTargetFunction(Workbook workbook, NameEval functionNameEval) throws EvaluationException {
+	private FreeRefFunction findExternalUserDefinedFunction(Workbook workbook,
+			NameXEval n) throws EvaluationException {
+		String functionName = workbook.resolveNameXText(n.getSheetRefIndex(), n.getNameNumber());
+
+		if(false) {
+			System.out.println("received call to external user defined function (" + functionName + ")");
+		}
+		// currently only looking for functions from the 'Analysis TookPak'
+		// not sure how much this logic would need to change to support other or multiple add-ins.
+		FreeRefFunction result = AnalysisToolPak.findFunction(functionName);
+		if (result != null) {
+			return result;
+		}
+		throw new EvaluationException(ErrorEval.FUNCTION_NOT_IMPLEMENTED);
+	}
+
+	private FreeRefFunction findInternalUserDefinedFunction(Workbook workbook, NameEval functionNameEval) throws EvaluationException {
 
 		int numberOfNames = workbook.getNumberOfNames();
 		
@@ -68,7 +86,7 @@ final class ExternalFunction implements FreeRefFunction {
 		
 		String functionName = workbook.getNameName(nameIndex);
 		if(false) {
-			System.out.println("received call to external function index (" + functionName + ")");
+			System.out.println("received call to internal user defined function  (" + functionName + ")");
 		}
 		// TODO - detect if the NameRecord corresponds to a named range, function, or something undefined
 		// throw the right errors in these cases
@@ -77,5 +95,5 @@ final class ExternalFunction implements FreeRefFunction {
 		
 		throw new EvaluationException(ErrorEval.FUNCTION_NOT_IMPLEMENTED);
 	}
-
 }
+

src/java/org/apache/poi/hssf/record/formula/eval/NameXEval.java

@@ -0,0 +1,49 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hssf.record.formula.eval;
+
+/**
+ * @author Josh Micich
+ */
+public final class NameXEval implements Eval {
+
+	/** index to REF entry in externsheet record */
+	private final int _sheetRefIndex;
+	/** index to defined name or externname table(1 based) */
+	private final int _nameNumber;
+
+	public NameXEval(int sheetRefIndex, int nameNumber) {
+		_sheetRefIndex = sheetRefIndex;
+		_nameNumber = nameNumber;
+	}
+
+	public int getSheetRefIndex() {
+		return _sheetRefIndex;
+	}
+	public int getNameNumber() {
+		return _nameNumber;
+	}
+
+	public String toString() {
+		StringBuffer sb = new StringBuffer(64);
+		sb.append(getClass().getName()).append(" [");
+		sb.append(_sheetRefIndex).append(", ").append(_nameNumber);
+		sb.append("]");
+		return sb.toString();
+	}
+}

src/java/org/apache/poi/hssf/usermodel/HSSFConditionalFormattingRule.java

@@ -41,6 +41,12 @@ public final class HSSFConditionalFormattingRule
 	private final HSSFWorkbook workbook;
 
 	HSSFConditionalFormattingRule(HSSFWorkbook pWorkbook, CFRuleRecord pRuleRecord) {
+		if (pWorkbook == null) {
+			throw new IllegalArgumentException("pWorkbook must not be null");
+		}
+		if (pRuleRecord == null) {
+			throw new IllegalArgumentException("pRuleRecord must not be null");
+		}
 		workbook = pWorkbook;
 		cfRuleRecord = pRuleRecord;
 	}

src/java/org/apache/poi/hssf/usermodel/HSSFRow.java

@@ -349,7 +349,7 @@ public final class HSSFRow implements Comparable, Row {
         }
         if(policy == CREATE_NULL_AS_BLANK) {
             if(cell == null) {
-                return createCell((short)cellnum, HSSFCell.CELL_TYPE_BLANK);
+                return createCell(cellnum, HSSFCell.CELL_TYPE_BLANK);
             }
             return cell;
         }

src/java/org/apache/poi/hssf/usermodel/HSSFSheet.java

@@ -1836,7 +1836,7 @@ public class HSSFSheet implements org.apache.poi.ss.usermodel.Sheet
         //  new HSSFComment instances, which is bad
         HSSFRow r = getRow(row);
         if(r != null) {
-            HSSFCell c = r.getCell((short)column);
+            HSSFCell c = r.getCell(column);
             if(c != null) {
                 return c.getCellComment();
             } else {

src/java/org/apache/poi/ss/usermodel/DateUtil.java

@@ -158,9 +158,16 @@ public class DateUtil {
         if (!isValidExcelDate(date)) {
             return null;
         }
+        int wholeDays = (int)Math.floor(date);
+        int millisecondsInDay = (int)((date - wholeDays) * DAY_MILLISECONDS + 0.5);
+        Calendar calendar = new GregorianCalendar(); // using default time-zone
+        setCalendar(calendar, wholeDays, millisecondsInDay, use1904windowing);
+        return calendar.getTime();
+    }        
+    public static void setCalendar(Calendar calendar, int wholeDays, 
+            int millisecondsInDay, boolean use1904windowing) {
         int startYear = 1900;
         int dayAdjust = -1; // Excel thinks 2/29/1900 is a valid date, which it isn't
-        int wholeDays = (int)Math.floor(date);
         if (use1904windowing) {
             startYear = 1904;
             dayAdjust = 1; // 1904 date windowing uses 1/2/1904 as the first day
@@ -170,12 +177,8 @@ public class DateUtil {
             // If Excel date == 2/29/1900, will become 3/1/1900 in Java representation
             dayAdjust = 0;
         }
-        GregorianCalendar calendar = new GregorianCalendar(startYear,0,
+        calendar.set(startYear,0, wholeDays + dayAdjust, 0, 0, 0);
-                                                 wholeDays + dayAdjust);
-        int millisecondsInDay = (int)((date - Math.floor(date)) *
-                                      DAY_MILLISECONDS + 0.5);
         calendar.set(GregorianCalendar.MILLISECOND, millisecondsInDay);
-        return calendar.getTime();
     }
 
     /**

src/java/org/apache/poi/ss/usermodel/FormulaEvaluator.java

@@ -50,6 +50,7 @@ import org.apache.poi.hssf.record.formula.eval.ErrorEval;
 import org.apache.poi.hssf.record.formula.eval.Eval;
 import org.apache.poi.hssf.record.formula.eval.FunctionEval;
 import org.apache.poi.hssf.record.formula.eval.NameEval;
+import org.apache.poi.hssf.record.formula.eval.NameXEval;
 import org.apache.poi.hssf.record.formula.eval.NumberEval;
 import org.apache.poi.hssf.record.formula.eval.OperationEval;
 import org.apache.poi.hssf.record.formula.eval.Ref2DEval;
@@ -348,7 +349,8 @@ public class FormulaEvaluator {
                 continue; 
             }
             if (ptg instanceof NameXPtg) {
-                // TODO - external functions
+                NameXPtg nameXPtg = (NameXPtg) ptg;
+                stack.push(new NameXEval(nameXPtg.getSheetRefIndex(), nameXPtg.getNameIndex()));
                 continue;
             }
             if (ptg instanceof UnknownPtg) { continue; }

src/scratchpad/src/org/apache/poi/hpbf/HPBFDocument.java

@@ -0,0 +1,86 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hpbf;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.apache.poi.POIDocument;
+import org.apache.poi.hpbf.model.EscherDelayStm;
+import org.apache.poi.hpbf.model.EscherStm;
+import org.apache.poi.hpbf.model.MainContents;
+import org.apache.poi.hpbf.model.QuillContents;
+import org.apache.poi.poifs.filesystem.DirectoryNode;
+import org.apache.poi.poifs.filesystem.POIFSFileSystem;
+
+/**
+ * This class provides the basic functionality 
+ *  for HPBF, our implementation of the publisher
+ *  file format. 
+ */
+public final class HPBFDocument extends POIDocument {
+	private MainContents mainContents;
+	private QuillContents quillContents;
+	private EscherStm escherStm;
+	private EscherDelayStm escherDelayStm;
+	
+	/**
+	 * Opens a new publisher document
+	 */
+	public HPBFDocument(POIFSFileSystem fs) throws IOException {
+		this(fs.getRoot(), fs);
+	}
+	public HPBFDocument(InputStream inp) throws IOException {
+		this(new POIFSFileSystem(inp));
+	}
+	
+	/**
+	 * Opens an embeded publisher document,
+	 *  at the given directory.
+	 */
+	public HPBFDocument(DirectoryNode dir, POIFSFileSystem fs) throws IOException {
+		super(dir, fs);
+		
+		// Go looking for our interesting child
+		//  streams
+		mainContents = new MainContents(dir);
+		quillContents = new QuillContents(dir);
+		
+		// Now the Escher bits
+		escherStm = new EscherStm(dir);
+		escherDelayStm = new EscherDelayStm(dir);
+	}
+
+	public MainContents getMainContents() {
+		return mainContents;
+	}
+	public QuillContents getQuillContents() {
+		return quillContents;
+	}
+	public EscherStm getEscherStm() {
+		return escherStm;
+	}
+	public EscherDelayStm getEscherDelayStm() {
+		return escherDelayStm;
+	}
+	
+	public void write(OutputStream out) throws IOException {
+		throw new IllegalStateException("Writing is not yet implemented, see http://poi.apache.org/hpbf/");
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/extractor/PublisherTextExtractor.java

@@ -0,0 +1,78 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.extractor;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import org.apache.poi.POIOLE2TextExtractor;
+import org.apache.poi.hpbf.HPBFDocument;
+import org.apache.poi.hpbf.model.qcbits.QCBit;
+import org.apache.poi.hpbf.model.qcbits.QCTextBit;
+import org.apache.poi.poifs.filesystem.POIFSFileSystem;
+
+/**
+ * Extract text from HPBF Publisher files 
+ */
+public class PublisherTextExtractor extends POIOLE2TextExtractor {
+	private HPBFDocument doc;
+	
+	public PublisherTextExtractor(HPBFDocument doc) {
+		super(doc);
+		this.doc = doc;
+	}
+	public PublisherTextExtractor(POIFSFileSystem fs) throws IOException {
+		this(new HPBFDocument(fs));
+	}
+	public PublisherTextExtractor(InputStream is) throws IOException {
+		this(new POIFSFileSystem(is));
+	}
+	
+	public String getText() {
+		StringBuffer text = new StringBuffer();
+		
+		// Get the text from the Quill Contents
+		QCBit[] bits = doc.getQuillContents().getBits();
+		for(int i=0; i<bits.length; i++) {
+			if(bits[i] != null && bits[i] instanceof QCTextBit) {
+				QCTextBit t = (QCTextBit)bits[i];
+				text.append( t.getText().replace('\r', '\n') );
+			}
+		}
+		
+		// Get more text
+		// TODO
+		
+		return text.toString();
+	}
+	
+	
+	public static void main(String[] args) throws Exception {
+		if(args.length == 0) {
+			System.err.println("Use:");
+			System.err.println("  PublisherTextExtractor <file.pub>");
+		}
+		
+		for(int i=0; i<args.length; i++) {
+			PublisherTextExtractor te = new PublisherTextExtractor(
+					new FileInputStream(args[i])
+			);
+			System.out.println(te.getText());
+		}
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/EscherDelayStm.java

@@ -0,0 +1,30 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hpbf.model;
+
+import java.io.IOException;
+
+import org.apache.poi.poifs.filesystem.DirectoryNode;
+
+public final class EscherDelayStm extends EscherPart {
+	private static final String[] PATH = { "Escher", "EscherDelayStm", };
+
+	public EscherDelayStm(DirectoryNode baseDir) throws IOException {
+		super(baseDir, PATH);
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/EscherPart.java

@@ -0,0 +1,80 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hpbf.model;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import org.apache.poi.ddf.DefaultEscherRecordFactory;
+import org.apache.poi.ddf.EscherRecord;
+import org.apache.poi.poifs.filesystem.DirectoryNode;
+
+/**
+ * Parent class of all Escher parts
+ */
+public abstract class EscherPart extends HPBFPart {
+	private EscherRecord[] records;
+	
+	/**
+	 * Creates the Escher Part, and finds our child
+	 *  escher records
+	 */
+	public EscherPart(DirectoryNode baseDir, String[] parts) throws IOException {
+		super(baseDir, parts);
+		
+		// Now create our Escher children
+		DefaultEscherRecordFactory erf = 
+			new DefaultEscherRecordFactory();
+		
+		ArrayList ec = new ArrayList();
+		int left = data.length;
+		while(left > 0) {
+			EscherRecord er = erf.createRecord(data, 0);
+			er.fillFields(data, 0, erf);
+			left -= er.getRecordSize();
+			
+			ec.add(er);
+		}
+		
+		records = (EscherRecord[])
+			ec.toArray(new EscherRecord[ec.size()]);
+	}
+	
+	public EscherRecord[] getEscherRecords() {
+		return records;
+	}
+	
+	/**
+	 * Serialises our Escher children back
+	 *  into bytes.
+	 */
+	protected void generateData() {
+		int size = 0;
+		for(int i=0; i<records.length; i++) {
+			size += records[i].getRecordSize(); 
+		}
+		
+		data = new byte[size];
+		size = 0;
+		for(int i=0; i<records.length; i++) {
+			int thisSize = 
+				records[i].serialize(size, data);
+			size += thisSize;
+		}
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/EscherStm.java

@@ -0,0 +1,29 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hpbf.model;
+
+import java.io.IOException;
+
+import org.apache.poi.poifs.filesystem.DirectoryNode;
+
+public final class EscherStm extends EscherPart {
+	private static final String[] PATH = { "Escher", "EscherStm", };
+	public EscherStm(DirectoryNode baseDir) throws IOException {
+		super(baseDir, PATH);
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/HPBFPart.java

@@ -0,0 +1,104 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.model;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import org.apache.poi.poifs.filesystem.DirectoryNode;
+import org.apache.poi.poifs.filesystem.DocumentEntry;
+
+/**
+ * Parent class of all HPBF sub-parts, handling
+ *  the fiddly reading in / writing out bits
+ *  for all of them.
+ */
+public abstract class HPBFPart {
+	protected byte[] data;
+	/**
+	 * @param path  the path to the part, eg Contents or Quill, QuillSub, CONTENTS
+	 */
+	public HPBFPart(DirectoryNode baseDir, String[] path) throws IOException {
+		 
+		DirectoryNode dir = getDir(path, baseDir);
+		String name = path[path.length-1];
+		
+		DocumentEntry docProps;
+		try {
+			docProps = (DocumentEntry)dir.getEntry(name);
+		} catch (FileNotFoundException e) {
+			throw new IllegalArgumentException("File invalid - failed to find document entry '" 
+					+ name + "'");
+		}
+
+		// Grab the data from the part stream
+		data = new byte[docProps.getSize()];
+		dir.createDocumentInputStream(name).read(data);
+	}
+	private DirectoryNode getDir(String[] path, DirectoryNode baseDir) {
+		DirectoryNode dir = baseDir;
+		for(int i=0; i<path.length-1; i++) {
+			try {
+				dir = (DirectoryNode)dir.getEntry(path[i]);
+			} catch (FileNotFoundException e) {
+				throw new IllegalArgumentException("File invalid - failed to find directory entry '" 
+						+ path[i] + "'");
+			}
+		}
+		return dir;
+	}
+	
+	public void writeOut(DirectoryNode baseDir) throws IOException {
+		String[] path = getPath();
+		
+		// Ensure that all parent directories exist
+		DirectoryNode dir = baseDir;
+		for(int i=0; i<path.length-1; i++) {
+			try {
+				dir = (DirectoryNode)dir.getEntry(path[i]);
+			} catch(FileNotFoundException e) {
+				dir.createDirectory(path[i]);
+			}
+		}
+		
+		// Update the byte array with the latest data
+		generateData();
+		
+		// Write out
+		ByteArrayInputStream bais = new ByteArrayInputStream(data);
+		dir.createDocument(path[path.length-1], bais);
+	}
+	
+	/**
+	 * Called just before writing out, to trigger
+	 *  the data byte array to be updated with the
+	 *  latest contents.
+	 */
+	protected abstract void generateData();
+	
+	/**
+	 * Returns the raw data that makes up
+	 *  this document part.
+	 */
+	public byte[] getData() { return data; }
+
+	/**
+	 * Returns
+	 */
+	public final String[] getPath() {return null;}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/MainContents.java

@@ -0,0 +1,38 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hpbf.model;
+
+import java.io.IOException;
+
+import org.apache.poi.poifs.filesystem.DirectoryNode;
+
+/**
+ * The main Contents. Not yet understood
+ */
+public final class MainContents extends HPBFPart {
+	private static final String[] PATH = { "Contents", };
+	
+	public MainContents(DirectoryNode baseDir) throws IOException {
+		super(baseDir, PATH);
+	}
+
+	protected void generateData() {
+		// We don't parse the contents, so
+		//  nothing will have changed
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/QuillContents.java

@@ -0,0 +1,87 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.model;
+
+import java.io.IOException;
+
+import org.apache.poi.hpbf.model.qcbits.QCBit;
+import org.apache.poi.hpbf.model.qcbits.QCTextBit;
+import org.apache.poi.hpbf.model.qcbits.UnknownQCBit;
+import org.apache.poi.poifs.filesystem.DirectoryNode;
+import org.apache.poi.util.LittleEndian;
+
+/**
+ * Quill -> QuillSub -> CONTENTS
+ */
+public final class QuillContents extends HPBFPart {
+	private static final String[] PATH = { "Quill", "QuillSub", "CONTENTS", };
+	private QCBit[] bits;
+	
+	public QuillContents(DirectoryNode baseDir) throws IOException {
+		super(baseDir, PATH);
+		
+		// Now parse the first 512 bytes, and produce
+		//  all our bits
+		
+		// Check first 8 bytes
+		String f8 = new String(data, 0, 8);
+		if(! f8.equals("CHNKINK ")) {
+			throw new IllegalArgumentException("Expecting 'CHNKINK ' but was '"+f8+"'");
+		}
+		// Ignore the next 24, for now at least
+		
+		// Now, parse all our QC Bits
+		bits = new QCBit[20];
+		for(int i=0; i<20; i++) {
+			int offset = 0x20 + i*24;
+			if(data[offset] == 0x18 && data[offset+1] == 0x00) {
+				// Has some data
+				String thingType = new String(data, offset+2, 4);
+				int optA = LittleEndian.getUShort(data, offset+6);
+				int optB = LittleEndian.getUShort(data, offset+8);
+				int optC = LittleEndian.getUShort(data, offset+10);
+				String bitType = new String(data, offset+12, 4);
+				int from = (int)LittleEndian.getUInt(data, offset+16);
+				int len = (int)LittleEndian.getUInt(data, offset+20);
+				
+				byte[] bitData = new byte[len];
+				System.arraycopy(data, from, bitData, 0, len);
+				
+				// Create
+				if(bitType.equals("TEXT")) {
+					bits[i] = new QCTextBit(thingType, bitType, bitData);
+				} else {
+					bits[i] = new UnknownQCBit(thingType, bitType, bitData);
+				}
+				bits[i].setOptA(optA);
+				bits[i].setOptB(optB);
+				bits[i].setOptC(optC);
+			} else {
+				// Doesn't have data
+			}
+		}
+	}
+
+	public QCBit[] getBits() {
+		return bits;
+	}
+	
+	protected void generateData() {
+		// TODO
+		throw new IllegalStateException("Not done yet!");
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/qcbits/QCBit.java

@@ -0,0 +1,69 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.model.qcbits;
+
+/**
+ * Parent of all Quill CONTENTS bits
+ */
+public abstract class QCBit {
+	protected String thingType;
+	protected String bitType;
+	protected byte[] data;
+	
+	protected int optA;
+	protected int optB;
+	protected int optC;
+	
+	public QCBit(String thingType, String bitType, byte[] data) {
+		this.thingType = thingType;
+		this.bitType = bitType;
+		this.data = data;
+	}
+	
+	/**
+	 * Returns the type of the thing, eg TEXT, FONT
+	 *  or TOKN
+	 */
+	public String getThingType() { return thingType; }
+	/**
+	 * Returns the type of the bit data, eg TEXT
+	 *  or PLC
+	 */
+	public String getBitType() { return bitType; }
+	public byte[] getData() { return data; }
+
+	public int getOptA() {
+		return optA;
+	}
+	public void setOptA(int optA) {
+		this.optA = optA;
+	}
+
+	public int getOptB() {
+		return optB;
+	}
+	public void setOptB(int optB) {
+		this.optB = optB;
+	}
+
+	public int getOptC() {
+		return optC;
+	}
+	public void setOptC(int optC) {
+		this.optC = optC;
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/qcbits/QCTextBit.java

@@ -0,0 +1,43 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.model.qcbits;
+
+import org.apache.poi.util.StringUtil;
+
+/**
+ * A Text based bit of Quill Contents
+ */
+public class QCTextBit extends QCBit {
+	public QCTextBit(String thingType, String bitType, byte[] data) {
+		super(thingType, bitType, data);
+	}
+
+	/**
+	 * Returns the text. Note that line endings
+	 *  are \r and not \n
+	 */
+	public String getText() {
+		return StringUtil.getFromUnicodeLE(
+				data, 0, data.length/2
+		);
+	}
+	
+	public void setText(String text) {
+		data = new byte[text.length()*2];
+		StringUtil.putUnicodeLE(text, data, 0);
+	}
+}

src/scratchpad/src/org/apache/poi/hpbf/model/qcbits/UnknownQCBit.java

@@ -0,0 +1,27 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.model.qcbits;
+
+/**
+ * Any Quill Contents bits we don't know
+ *  how to handle explicitly
+ */
+public class UnknownQCBit extends QCBit {
+	public UnknownQCBit(String thingType, String bitType, byte[] data) {
+		super(thingType, bitType, data);
+	}
+}

src/scratchpad/testcases/org/apache/poi/hpbf/TestHPBFDocument.java

@@ -0,0 +1,60 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf;
+
+import java.io.File;
+import java.io.FileInputStream;
+
+import junit.framework.TestCase;
+
+public class TestHPBFDocument extends TestCase {
+	private String dir;
+
+	protected void setUp() throws Exception {
+		dir = System.getProperty("HPBF.testdata.path");
+	}
+
+	public void testOpen() throws Exception {
+		File f = new File(dir, "Sample.pub");
+		HPBFDocument doc = new HPBFDocument(
+				new FileInputStream(f)
+		);
+		
+		assertNotNull(doc);
+	}
+	
+	public void testBits() throws Exception {
+		File f = new File(dir, "Sample.pub");
+		HPBFDocument doc = new HPBFDocument(
+				new FileInputStream(f)
+		);
+
+		assertNotNull(doc.getMainContents());
+		assertNotNull(doc.getQuillContents());
+		assertNotNull(doc.getEscherStm());
+		assertNotNull(doc.getEscherDelayStm());
+		
+		assertTrue(doc.getMainContents().getData().length > 0);
+		assertTrue(doc.getQuillContents().getData().length > 0);
+		assertTrue(doc.getEscherStm().getData().length > 0);
+		assertTrue(doc.getEscherDelayStm().getData().length == 0);
+	}
+	
+	// TODO
+//	public void testWrite() throws Exception {
+//	}
+}

src/scratchpad/testcases/org/apache/poi/hpbf/extractor/TextPublisherTextExtractor.java

@@ -0,0 +1,105 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.extractor;
+
+import java.io.File;
+import java.io.FileInputStream;
+
+import org.apache.poi.hpbf.HPBFDocument;
+
+import junit.framework.TestCase;
+
+public class TextPublisherTextExtractor extends TestCase {
+	private String dir;
+
+	protected void setUp() throws Exception {
+		dir = System.getProperty("HPBF.testdata.path");
+	}
+
+	public void testBasics() throws Exception {
+		File f = new File(dir, "Sample.pub");
+		HPBFDocument doc = new HPBFDocument(
+				new FileInputStream(f)
+		);
+
+		PublisherTextExtractor ext = 
+			new PublisherTextExtractor(doc);
+		ext.getText();
+		
+		f = new File(dir, "Simple.pub");
+		ext = new PublisherTextExtractor(
+				new FileInputStream(f)
+		);
+		ext.getText();
+	}
+	
+	public void testContents() throws Exception {
+		File f = new File(dir, "Sample.pub");
+		HPBFDocument doc = new HPBFDocument(
+				new FileInputStream(f)
+		);
+
+		PublisherTextExtractor ext = 
+			new PublisherTextExtractor(doc);
+		String text = ext.getText();
+		
+		assertEquals(
+"This is some text on the first page\n" +
+"It’s in times new roman, font size 10, all normal\n" +
+"" +
+"This is in bold and italic\n" +
+"It’s Arial, 20 point font\n" +
+"It’s in the second textbox on the first page\n" +
+"" +
+"This is the second page\n\n" +
+"" +
+"It is also times new roman, 10 point\n" +
+"" +
+"Table on page 2\nTop right\n" +
+"P2 table left\nP2 table right\n" +
+"Bottom Left\nBottom Right\n" +
+"" +
+"This text is on page two\n" +
+"#This is a link to Apache POI\n" +
+"More normal text\n" +
+"Link to a file\n" +
+"" +
+"More text, more hyperlinks\n" +
+"email link\n" +
+"Final hyperlink\n" +
+"Within doc to page 1\n"
+				, text
+		);
+		
+		// Now a simpler one
+		f = new File(dir, "Simple.pub");
+		ext = new PublisherTextExtractor(
+				new FileInputStream(f)
+		);
+		text = ext.getText();
+		assertEquals(
+"0123456789\n" +
+"0123456789abcdef\n" +
+"0123456789abcdef0123456789abcdef\n" +
+"0123456789\n" +
+"0123456789abcdef\n" +
+"0123456789abcdef0123456789abcdef\n" +
+"0123456789abcdef0123456789abcdef0123456789abcdef\n"
+				, text
+		);
+	}
+}

src/scratchpad/testcases/org/apache/poi/hpbf/model/TestEscherParts.java

@@ -0,0 +1,50 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.model;
+
+import java.io.File;
+import java.io.FileInputStream;
+
+import org.apache.poi.hpbf.HPBFDocument;
+
+import junit.framework.TestCase;
+
+public class TestEscherParts extends TestCase {
+	private String dir;
+
+	protected void setUp() throws Exception {
+		dir = System.getProperty("HPBF.testdata.path");
+	}
+
+	public void testBasics() throws Exception {
+		File f = new File(dir, "Sample.pub");
+		HPBFDocument doc = new HPBFDocument(
+				new FileInputStream(f)
+		);
+
+		EscherStm es = doc.getEscherStm();
+		EscherDelayStm eds = doc.getEscherDelayStm();
+		
+		assertNotNull(es);
+		assertNotNull(eds);
+		
+		assertEquals(13, es.getEscherRecords().length);
+		assertEquals(0, eds.getEscherRecords().length);
+		
+		// TODO - check the contents
+	}
+}

src/scratchpad/testcases/org/apache/poi/hpbf/model/TestQuillContents.java

@@ -0,0 +1,80 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+package org.apache.poi.hpbf.model;
+
+import java.io.File;
+import java.io.FileInputStream;
+
+import org.apache.poi.hpbf.HPBFDocument;
+import org.apache.poi.hpbf.model.qcbits.QCTextBit;
+
+import junit.framework.TestCase;
+
+public class TestQuillContents extends TestCase {
+	private String dir;
+
+	protected void setUp() throws Exception {
+		dir = System.getProperty("HPBF.testdata.path");
+	}
+
+	public void testBasics() throws Exception {
+		File f = new File(dir, "Sample.pub");
+		HPBFDocument doc = new HPBFDocument(
+				new FileInputStream(f)
+		);
+		
+		QuillContents qc = doc.getQuillContents();
+		assertEquals(20, qc.getBits().length);
+		for(int i=0; i<19; i++) {
+			assertNotNull(qc.getBits()[i]);
+		}
+		// Last one is blank
+		assertNull(qc.getBits()[19]);
+		
+		// Should be text, then three STSHs
+		assertEquals("TEXT", qc.getBits()[0].getThingType());
+		assertEquals("TEXT", qc.getBits()[0].getBitType());
+		assertEquals(0, qc.getBits()[0].getOptA());
+		
+		assertEquals("STSH", qc.getBits()[1].getThingType());
+		assertEquals("STSH", qc.getBits()[1].getBitType());
+		assertEquals(0, qc.getBits()[1].getOptA());
+		
+		assertEquals("STSH", qc.getBits()[2].getThingType());
+		assertEquals("STSH", qc.getBits()[2].getBitType());
+		assertEquals(1, qc.getBits()[2].getOptA());
+		
+		assertEquals("STSH", qc.getBits()[3].getThingType());
+		assertEquals("STSH", qc.getBits()[3].getBitType());
+		assertEquals(2, qc.getBits()[3].getOptA());
+	}
+	
+	public void testText() throws Exception {
+		File f = new File(dir, "Sample.pub");
+		HPBFDocument doc = new HPBFDocument(
+				new FileInputStream(f)
+		);
+		
+		QuillContents qc = doc.getQuillContents();
+		assertEquals(20, qc.getBits().length);
+		
+		QCTextBit text = (QCTextBit)qc.getBits()[0];
+		String t = text.getText();
+		assertTrue(t.startsWith("This is some text on the first page"));
+		assertTrue(t.endsWith("Within doc to page 1\r"));
+	}
+}

src/testcases/org/apache/poi/hssf/eventmodel/TestModelFactory.java

@@ -139,7 +139,7 @@ public class TestModelFactory extends TestCase
         ByteArrayOutputStream stream = new ByteArrayOutputStream();
         HSSFSheet sheet = book.createSheet("Test");
         HSSFRow   row   = sheet.createRow(0);
-        HSSFCell  cell  = row.createCell((short)0);
+        HSSFCell  cell  = row.createCell(0);
         cell.setCellValue(10.5);
         book.write(stream);
         return stream;

src/testcases/org/apache/poi/hssf/eventusermodel/TestMissingRecordAwareHSSFListener.java

@@ -21,6 +21,7 @@ import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
 
+import junit.framework.AssertionFailedError;
 import junit.framework.TestCase;
 
 import org.apache.poi.hssf.HSSFTestDataSamples;
@@ -31,6 +32,7 @@ import org.apache.poi.hssf.record.BOFRecord;
 import org.apache.poi.hssf.record.LabelSSTRecord;
 import org.apache.poi.hssf.record.Record;
 import org.apache.poi.hssf.record.RowRecord;
+import org.apache.poi.hssf.record.SharedFormulaRecord;
 import org.apache.poi.poifs.filesystem.POIFSFileSystem;
 /**
  * Tests for MissingRecordAwareHSSFListener
@@ -39,44 +41,29 @@ public final class TestMissingRecordAwareHSSFListener extends TestCase {
 	
 	private Record[] r;
 
+	private void readRecords(String sampleFileName) {
+		HSSFRequest req = new HSSFRequest();
+		MockHSSFListener mockListen = new MockHSSFListener();
+		MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(mockListen);
+		req.addListenerForAllRecords(listener);
+		
+		HSSFEventFactory factory = new HSSFEventFactory();
+		try {
+			InputStream is = HSSFTestDataSamples.openSampleFileStream(sampleFileName);
+			POIFSFileSystem fs = new POIFSFileSystem(is);
+			factory.processWorkbookEvents(req, fs);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		
+		r = mockListen.getRecords();
+		assertTrue(r.length > 100);
+	} 
 	public void openNormal() {
-		HSSFRequest req = new HSSFRequest();
+		readRecords("MissingBits.xls");
-		MockHSSFListener mockListen = new MockHSSFListener();
+	}
-		MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(mockListen);
-		req.addListenerForAllRecords(listener);
-		
-		HSSFEventFactory factory = new HSSFEventFactory();
-		try {
-			InputStream is = HSSFTestDataSamples.openSampleFileStream("MissingBits.xls");
-			POIFSFileSystem fs = new POIFSFileSystem(is);
-			factory.processWorkbookEvents(req, fs);
-		} catch (IOException e) {
-			throw new RuntimeException(e);
-		}
-		
-		r = mockListen.getRecords();
-		assertTrue(r.length > 100);
-	} 
-	public void openAlt() {
-		HSSFRequest req = new HSSFRequest();
-		MockHSSFListener mockListen = new MockHSSFListener();
-		MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(mockListen);
-		req.addListenerForAllRecords(listener);
-		
-		HSSFEventFactory factory = new HSSFEventFactory();
-		try {
-			InputStream is = HSSFTestDataSamples.openSampleFileStream("MRExtraLines.xls");
-			POIFSFileSystem fs = new POIFSFileSystem(is);
-			factory.processWorkbookEvents(req, fs);
-		} catch (IOException e) {
-			throw new RuntimeException(e);
-		}
-		
-		r = mockListen.getRecords();
-		assertTrue(r.length > 100);
-	} 
 	
-	public void testMissingRowRecords() throws Exception {
+	public void testMissingRowRecords() {
 		openNormal();
 		
 		// We have rows 0, 1, 2, 20 and 21
@@ -126,7 +113,7 @@ public final class TestMissingRecordAwareHSSFListener extends TestCase {
 		assertEquals(19, mr.getRowNumber());
 	}
 	
-	public void testEndOfRowRecords() throws Exception {
+	public void testEndOfRowRecords() {
 		openNormal();
 		
 		// Find the cell at 0,0
@@ -248,7 +235,7 @@ public final class TestMissingRecordAwareHSSFListener extends TestCase {
 	}
 	
 	
-	public void testMissingCellRecords() throws Exception {
+	public void testMissingCellRecords() {
 		openNormal();
 		
 		// Find the cell at 0,0
@@ -350,29 +337,21 @@ public final class TestMissingRecordAwareHSSFListener extends TestCase {
 	
 	// Make sure we don't put in any extra new lines
 	//  that aren't already there
-	public void testNoExtraNewLines() throws Exception {
+	public void testNoExtraNewLines() {
 		// Load a different file
-		openAlt();
-		
-		
 		// This file has has something in lines 1-33
-		List lcor = new ArrayList();
+		readRecords("MRExtraLines.xls");
+		
+		int rowCount=0;
 		for(int i=0; i<r.length; i++) {
-			if(r[i] instanceof LastCellOfRowDummyRecord)
+			if(r[i] instanceof LastCellOfRowDummyRecord) {
-				lcor.add( (LastCellOfRowDummyRecord)r[i] );
+				LastCellOfRowDummyRecord eor = (LastCellOfRowDummyRecord) r[i];
+				assertEquals(rowCount, eor.getRow());
+				rowCount++;
+			}
 		}
-		
 		// Check we got the 33 rows
-		assertEquals(33, lcor.size());
+		assertEquals(33, rowCount);
-		LastCellOfRowDummyRecord[] rowEnds = (LastCellOfRowDummyRecord[])
-			lcor.toArray(new LastCellOfRowDummyRecord[lcor.size()]);
-		assertEquals(33, rowEnds.length);
-		
-		// And check they have the right stuff in them,
-		//  no repeats
-		for(int i=0; i<rowEnds.length; i++) {
-			assertEquals(i, rowEnds[i].getRow());
-		}
 	}
 
 	private static final class MockHSSFListener implements HSSFListener {
@@ -418,4 +397,29 @@ public final class TestMissingRecordAwareHSSFListener extends TestCase {
 			return result;
 		}
 	}
+	
+	/**
+	 * Make sure that the presence of shared formulas does not cause extra 
+	 * end-of-row records.
+	 */
+	public void testEndOfRow_bug45672() {
+		readRecords("ex45672.xls");
+		Record[] rr = r;
+		int eorCount=0;
+		int sfrCount=0;
+		for (int i = 0; i < rr.length; i++) {
+			Record record = rr[i];
+			if (record instanceof SharedFormulaRecord) {
+				sfrCount++;
+			}
+			if (record instanceof LastCellOfRowDummyRecord) {
+				eorCount++;
+			}
+		}
+		if (eorCount == 2) {
+			throw new AssertionFailedError("Identified bug 45672");
+		}
+		assertEquals(1, eorCount);
+		assertEquals(1, sfrCount);
+	}
 }

src/testcases/org/apache/poi/hssf/record/TestSSTRecord.java

@@ -365,8 +365,8 @@ public final class TestSSTRecord extends TestCase {
     {
         HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("duprich1.xls");
         HSSFSheet sheet = wb.getSheetAt( 1 );
-        assertEquals( "01/05 (Wed)", sheet.getRow( 0 ).getCell( (short) 8 ).getStringCellValue() );
+        assertEquals( "01/05 (Wed)", sheet.getRow( 0 ).getCell(8 ).getStringCellValue() );
-        assertEquals( "01/05 (Wed)", sheet.getRow( 1 ).getCell( (short) 8 ).getStringCellValue() );
+        assertEquals( "01/05 (Wed)", sheet.getRow( 1 ).getCell(8 ).getStringCellValue() );
 
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         wb.write( baos );
@@ -375,12 +375,12 @@ public final class TestSSTRecord extends TestCase {
         wb = HSSFTestDataSamples.openSampleWorkbook("duprich2.xls");
         sheet = wb.getSheetAt( 0 );
         int row = 0;
-        assertEquals( "Testing", sheet.getRow( row++ ).getCell( (short) 0 ).getStringCellValue() );
+        assertEquals( "Testing", sheet.getRow( row++ ).getCell(0 ).getStringCellValue() );
-        assertEquals( "rich", sheet.getRow( row++ ).getCell( (short) 0 ).getStringCellValue() );
+        assertEquals( "rich", sheet.getRow( row++ ).getCell(0 ).getStringCellValue() );
-        assertEquals( "text", sheet.getRow( row++ ).getCell( (short) 0 ).getStringCellValue() );
+        assertEquals( "text", sheet.getRow( row++ ).getCell(0 ).getStringCellValue() );
-        assertEquals( "strings", sheet.getRow( row++ ).getCell( (short) 0 ).getStringCellValue() );
+        assertEquals( "strings", sheet.getRow( row++ ).getCell(0 ).getStringCellValue() );
-        assertEquals( "Testing", sheet.getRow( row++ ).getCell( (short) 0 ).getStringCellValue() );
+        assertEquals( "Testing", sheet.getRow( row++ ).getCell(0 ).getStringCellValue() );
-        assertEquals( "Testing", sheet.getRow( row++ ).getCell( (short) 0 ).getStringCellValue() );
+        assertEquals( "Testing", sheet.getRow( row++ ).getCell(0 ).getStringCellValue() );
 
         wb.write( baos );
     }

src/testcases/org/apache/poi/hssf/record/aggregates/TestCFRecordsAggregate.java

@@ -22,6 +22,7 @@ import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
 
+import junit.framework.AssertionFailedError;
 import junit.framework.TestCase;
 
 import org.apache.poi.hssf.model.RecordStream;
@@ -31,6 +32,7 @@ import org.apache.poi.hssf.record.RecordFactory;
 import org.apache.poi.hssf.record.CFRuleRecord.ComparisonOperator;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.util.LittleEndian;
 
 /**
  * Tests the serialization and deserialization of the CFRecordsAggregate
@@ -63,7 +65,8 @@ public final class TestCFRecordsAggregate extends TestCase
 		record = CFRecordsAggregate.createCFAggregate(new RecordStream(recs, 0));
 
 		// Serialize
-		byte [] serializedRecord = record.serialize();
+		byte [] serializedRecord = new byte[record.getRecordSize()];
+		record.serialize(0, serializedRecord);
 		InputStream in = new ByteArrayInputStream(serializedRecord);
 
 		//Parse
@@ -98,4 +101,28 @@ public final class TestCFRecordsAggregate extends TestCase
 		assertEquals(2, cellRanges.length);
 		assertEquals(3, header.getNumberOfConditionalFormats());
 	}
+	
+	/**
+	 * Make sure that the CF Header record is properly updated with the number of rules
+	 */
+	public void testNRules() {
+		HSSFWorkbook workbook = new HSSFWorkbook();
+		CellRangeAddress[] cellRanges = {
+				new CellRangeAddress(0,1,0,0),
+				new CellRangeAddress(0,1,2,2),
+		};
+		CFRuleRecord[] rules = {
+			CFRuleRecord.create(workbook, "7"),
+			CFRuleRecord.create(workbook, ComparisonOperator.BETWEEN, "2", "5"),
+		};
+		CFRecordsAggregate agg = new CFRecordsAggregate(cellRanges, rules);
+		byte[] serializedRecord = new byte[agg.getRecordSize()];
+		agg.serialize(0, serializedRecord);
+		
+		int nRules = LittleEndian.getUShort(serializedRecord, 4);
+		if (nRules == 0) {
+			throw new AssertionFailedError("Identified bug 45682 b");
+		}
+		assertEquals(rules.length, nRules);
+	}
 }

src/testcases/org/apache/poi/hssf/record/aggregates/TestValueRecordsAggregate.java

@@ -257,7 +257,7 @@ public class TestValueRecordsAggregate extends TestCase
         }
     }
     private static String getFormulaFromFirstCell(HSSFSheet s, int rowIx) {
-        return s.getRow(rowIx).getCell((short)0).getCellFormula();
+        return s.getRow(rowIx).getCell(0).getCellFormula();
     }
 
     /**

src/testcases/org/apache/poi/hssf/record/formula/TestAreaErrPtg.java

@@ -34,7 +34,7 @@ public class TestAreaErrPtg extends AbstractPtgTestCase
     {
         HSSFWorkbook workbook = loadWorkbook("AreaErrPtg.xls");
         assertEquals("Wrong formula string for area error", "SUM(#REF!)",
-                     workbook.getSheetAt(0).getRow(0).getCell((short) 2).getCellFormula());
+                     workbook.getSheetAt(0).getRow(0).getCell(2).getCellFormula());
     }
 }
 

src/testcases/org/apache/poi/hssf/record/formula/TestArrayPtg.java

@@ -103,7 +103,7 @@ public final class TestArrayPtg extends TestCase {
 		HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("ex42564-elementOrder.xls");
 
 		// The formula has an array with 3 rows and 5 columns 
-		String formula = wb.getSheetAt(0).getRow(0).getCell((short)0).getCellFormula();
+		String formula = wb.getSheetAt(0).getRow(0).getCell(0).getCellFormula();
 		// TODO - These number literals should not have '.0'. Excel has different number rendering rules
 
 		if (formula.equals("SUM({1.0,6.0,11.0;2.0,7.0,12.0;3.0,8.0,13.0;4.0,9.0,14.0;5.0,10.0,15.0})")) {

src/testcases/org/apache/poi/hssf/record/formula/TestErrPtg.java

@@ -34,7 +34,7 @@ public class TestErrPtg extends AbstractPtgTestCase
     public void testReading() throws Exception
     {
         HSSFWorkbook workbook = loadWorkbook("ErrPtg.xls");
-        HSSFCell cell = workbook.getSheetAt(0).getRow(3).getCell((short) 0);
+        HSSFCell cell = workbook.getSheetAt(0).getRow(3).getCell(0);
         assertEquals("Wrong cell value", 4.0, cell.getNumericCellValue(), 0.0);
         assertEquals("Wrong cell formula", "ERROR.TYPE(#REF!)", cell.getCellFormula());
     }

src/testcases/org/apache/poi/hssf/record/formula/TestExternalFunctionFormulas.java

@@ -71,7 +71,7 @@ public final class TestExternalFunctionFormulas extends TestCase {
 		}
 	}
 	
-	public void DISABLEDtestEvaluate() {
+	public void testEvaluate() {
 		HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("externalFunctionExample.xls");
 		HSSFSheet sheet = wb.getSheetAt(0);
 		HSSFCell cell = sheet.getRow(0).getCell(0);

src/testcases/org/apache/poi/hssf/record/formula/TestIntersectionPtg.java

@@ -34,7 +34,7 @@ public class TestIntersectionPtg extends AbstractPtgTestCase
     public void testReading() throws Exception
     {
         HSSFWorkbook workbook = loadWorkbook("IntersectionPtg.xls");
-        HSSFCell cell = workbook.getSheetAt(0).getRow(4).getCell((short) 2);
+        HSSFCell cell = workbook.getSheetAt(0).getRow(4).getCell(2);
         assertEquals("Wrong cell value", 5.0, cell.getNumericCellValue(), 0.0);
         assertEquals("Wrong cell formula", "SUM(A1:B2 B2:C3)", cell.getCellFormula());
     }

src/testcases/org/apache/poi/hssf/record/formula/TestPercentPtg.java

@@ -37,11 +37,11 @@ public class TestPercentPtg extends AbstractPtgTestCase
         HSSFSheet sheet = workbook.getSheetAt(0);
 
         assertEquals("Wrong numeric value for original number", 53000.0,
-                     sheet.getRow(0).getCell((short) 0).getNumericCellValue(), 0.0);
+                     sheet.getRow(0).getCell(0).getNumericCellValue(), 0.0);
         assertEquals("Wrong numeric value for percent formula result", 5300.0,
-                     sheet.getRow(1).getCell((short) 0).getNumericCellValue(), 0.0);
+                     sheet.getRow(1).getCell(0).getNumericCellValue(), 0.0);
         assertEquals("Wrong formula string for percent formula", "A1*10%",
-                     sheet.getRow(1).getCell((short) 0).getCellFormula());
+                     sheet.getRow(1).getCell(0).getCellFormula());
     }
 }
 

src/testcases/org/apache/poi/hssf/record/formula/TestRangePtg.java

@@ -34,7 +34,7 @@ public class TestRangePtg extends AbstractPtgTestCase
     public void testReading() throws Exception
     {
         HSSFWorkbook workbook = loadWorkbook("RangePtg.xls");
-        HSSFCell cell = workbook.getSheetAt(0).getRow(3).getCell((short) 1);
+        HSSFCell cell = workbook.getSheetAt(0).getRow(3).getCell(1);
         assertEquals("Wrong cell value", 10.0, cell.getNumericCellValue(), 0.0);
         assertEquals("Wrong cell formula", "SUM(pineapple:B2)", cell.getCellFormula());
     }

src/testcases/org/apache/poi/hssf/record/formula/TestReferencePtg.java

@@ -41,41 +41,41 @@ public final class TestReferencePtg extends TestCase {
 
         // First row
         assertEquals("Wrong numeric value for original number", 55.0,
-                     sheet.getRow(0).getCell((short) 0).getNumericCellValue(), 0.0);
+                     sheet.getRow(0).getCell(0).getNumericCellValue(), 0.0);
         assertEquals("Wrong numeric value for referemce", 55.0,
-                     sheet.getRow(0).getCell((short) 1).getNumericCellValue(), 0.0);
+                     sheet.getRow(0).getCell(1).getNumericCellValue(), 0.0);
         assertEquals("Wrong formula string for reference", "A1",
-                     sheet.getRow(0).getCell((short) 1).getCellFormula());
+                     sheet.getRow(0).getCell(1).getCellFormula());
         
         // Now moving over the 2**15 boundary
         // (Remember that excel row (n) is poi row (n-1)
         assertEquals("Wrong numeric value for original number", 32767.0,
-                sheet.getRow(32766).getCell((short) 0).getNumericCellValue(), 0.0);
+                sheet.getRow(32766).getCell(0).getNumericCellValue(), 0.0);
         assertEquals("Wrong numeric value for referemce", 32767.0,
-                sheet.getRow(32766).getCell((short) 1).getNumericCellValue(), 0.0);
+                sheet.getRow(32766).getCell(1).getNumericCellValue(), 0.0);
         assertEquals("Wrong formula string for reference", "A32767",
-                sheet.getRow(32766).getCell((short) 1).getCellFormula());
+                sheet.getRow(32766).getCell(1).getCellFormula());
         
         assertEquals("Wrong numeric value for original number", 32768.0,
-                sheet.getRow(32767).getCell((short) 0).getNumericCellValue(), 0.0);
+                sheet.getRow(32767).getCell(0).getNumericCellValue(), 0.0);
         assertEquals("Wrong numeric value for referemce", 32768.0,
-                sheet.getRow(32767).getCell((short) 1).getNumericCellValue(), 0.0);
+                sheet.getRow(32767).getCell(1).getNumericCellValue(), 0.0);
         assertEquals("Wrong formula string for reference", "A32768",
-                sheet.getRow(32767).getCell((short) 1).getCellFormula());
+                sheet.getRow(32767).getCell(1).getCellFormula());
         
         assertEquals("Wrong numeric value for original number", 32769.0,
-                sheet.getRow(32768).getCell((short) 0).getNumericCellValue(), 0.0);
+                sheet.getRow(32768).getCell(0).getNumericCellValue(), 0.0);
         assertEquals("Wrong numeric value for referemce", 32769.0,
-                sheet.getRow(32768).getCell((short) 1).getNumericCellValue(), 0.0);
+                sheet.getRow(32768).getCell(1).getNumericCellValue(), 0.0);
         assertEquals("Wrong formula string for reference", "A32769",
-                sheet.getRow(32768).getCell((short) 1).getCellFormula());
+                sheet.getRow(32768).getCell(1).getCellFormula());
         
         assertEquals("Wrong numeric value for original number", 32770.0,
-                sheet.getRow(32769).getCell((short) 0).getNumericCellValue(), 0.0);
+                sheet.getRow(32769).getCell(0).getNumericCellValue(), 0.0);
         assertEquals("Wrong numeric value for referemce", 32770.0,
-                sheet.getRow(32769).getCell((short) 1).getNumericCellValue(), 0.0);
+                sheet.getRow(32769).getCell(1).getNumericCellValue(), 0.0);
         assertEquals("Wrong formula string for reference", "A32770",
-                sheet.getRow(32769).getCell((short) 1).getCellFormula());
+                sheet.getRow(32769).getCell(1).getCellFormula());
     }
     
     public void testBug44921() {

src/testcases/org/apache/poi/hssf/record/formula/TestUnionPtg.java

@@ -34,7 +34,7 @@ public class TestUnionPtg extends AbstractPtgTestCase
     public void testReading() throws Exception
     {
         HSSFWorkbook workbook = loadWorkbook("UnionPtg.xls");
-        HSSFCell cell = workbook.getSheetAt(0).getRow(4).getCell((short) 2);
+        HSSFCell cell = workbook.getSheetAt(0).getRow(4).getCell(2);
         assertEquals("Wrong cell value", 24.0, cell.getNumericCellValue(), 0.0);
         assertEquals("Wrong cell formula", "SUM(A1:B2,B2:C3)", cell.getCellFormula());
     }

src/testcases/org/apache/poi/hssf/record/formula/atp/TestYearFracCalculator.java

@@ -0,0 +1,66 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hssf.record.formula.atp;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+
+import junit.framework.TestCase;
+
+import org.apache.poi.hssf.record.formula.eval.EvaluationException;
+import org.apache.poi.hssf.usermodel.HSSFDateUtil;
+
+/**
+ * Specific test cases for YearFracCalculator
+ */
+public final class TestYearFracCalculator extends TestCase {
+
+	public void testBasis1() {
+		confirm(md(1999, 1, 1), md(1999, 4, 5), 1, 0.257534247);
+		confirm(md(1999, 4, 1), md(1999, 4, 5), 1, 0.010958904);
+		confirm(md(1999, 4, 1), md(1999, 4, 4), 1, 0.008219178);
+		confirm(md(1999, 4, 2), md(1999, 4, 5), 1, 0.008219178);
+		confirm(md(1999, 3, 31), md(1999, 4, 3), 1, 0.008219178);
+		confirm(md(1999, 4, 5), md(1999, 4, 8), 1, 0.008219178);
+		confirm(md(1999, 4, 4), md(1999, 4, 7), 1, 0.008219178);
+	}
+
+	private void confirm(double startDate, double endDate, int basis, double expectedValue) {
+		double actualValue;
+		try {
+			actualValue = YearFracCalculator.calculate(startDate, endDate, basis);
+		} catch (EvaluationException e) {
+			throw new RuntimeException(e);
+		}
+		double diff = actualValue - expectedValue;
+		if (Math.abs(diff) >  0.000000001) {
+			double hours = diff * 365 * 24;
+			System.out.println(startDate + " " + endDate + " off by " + hours + " hours");
+			assertEquals(expectedValue, actualValue, 0.000000001);
+		}
+		
+	}
+
+	private static double md(int year, int month, int day) {
+		Calendar c = new GregorianCalendar();
+		
+		c.set(year, month-1, day, 0, 0, 0);
+		c.set(Calendar.MILLISECOND, 0);
+		return HSSFDateUtil.getExcelDate(c.getTime());
+	}
+}

src/testcases/org/apache/poi/hssf/record/formula/atp/TestYearFracCalculatorFromSpreadsheet.java

@@ -0,0 +1,178 @@
+/* ====================================================================
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You under the Apache License, Version 2.0
+   (the "License"); you may not use this file except in compliance with
+   the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+==================================================================== */
+
+package org.apache.poi.hssf.record.formula.atp;
+
+import java.io.PrintStream;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.Iterator;
+
+import junit.framework.Assert;
+import junit.framework.AssertionFailedError;
+import junit.framework.ComparisonFailure;
+import junit.framework.TestCase;
+
+import org.apache.poi.hssf.HSSFTestDataSamples;
+import org.apache.poi.hssf.record.formula.eval.EvaluationException;
+import org.apache.poi.hssf.usermodel.HSSFCell;
+import org.apache.poi.hssf.usermodel.HSSFDateUtil;
+import org.apache.poi.hssf.usermodel.HSSFFormulaEvaluator;
+import org.apache.poi.hssf.usermodel.HSSFRow;
+import org.apache.poi.hssf.usermodel.HSSFSheet;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+
+/**
+ * Tests YearFracCalculator using test-cases listed in a sample spreadsheet
+ * 
+ * @author Josh Micich
+ */
+public final class TestYearFracCalculatorFromSpreadsheet extends TestCase {
+	
+	private static final class SS {
+
+		public static final int BASIS_COLUMN = 1; // "B"
+		public static final int START_YEAR_COLUMN = 2; // "C"
+		public static final int END_YEAR_COLUMN = 5; // "F"
+		public static final int YEARFRAC_FORMULA_COLUMN = 11; // "L"
+		public static final int EXPECTED_RESULT_COLUMN = 13; // "N"
+	}
+
+	public void testAll() {
+		
+		HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook("yearfracExamples.xls");
+		HSSFSheet sheet = wb.getSheetAt(0);
+		HSSFFormulaEvaluator formulaEvaluator = new HSSFFormulaEvaluator(sheet, wb);
+		int nSuccess = 0;
+		int nFailures = 0;
+		int nUnexpectedErrors = 0;
+		Iterator rowIterator = sheet.rowIterator();
+		while(rowIterator.hasNext()) {
+			HSSFRow row = (HSSFRow) rowIterator.next();
+			
+			HSSFCell cell = row.getCell(SS.YEARFRAC_FORMULA_COLUMN);
+			if (cell == null || cell.getCellType() != HSSFCell.CELL_TYPE_FORMULA) {
+				continue;
+			}
+			try {
+				processRow(row, cell, formulaEvaluator);
+				nSuccess++;
+			} catch (RuntimeException e) {
+				nUnexpectedErrors ++;
+				printShortStackTrace(System.err, e);
+			} catch (AssertionFailedError e) {
+				nFailures ++;
+				printShortStackTrace(System.err, e);
+			}
+		}
+		if (nUnexpectedErrors + nFailures > 0) {
+			String msg = nFailures + " failures(s) and " + nUnexpectedErrors 
+				+ " unexpected errors(s) occurred. See stderr for details";
+			throw new AssertionFailedError(msg);
+		}
+		if (nSuccess < 1) {
+			throw new RuntimeException("No test sample cases found");
+		}
+	}
+	
+	private static void processRow(HSSFRow row, HSSFCell cell, HSSFFormulaEvaluator formulaEvaluator) {
+		
+		double startDate = makeDate(row, SS.START_YEAR_COLUMN);
+		double endDate = makeDate(row, SS.END_YEAR_COLUMN);
+		
+		int basis = getIntCell(row, SS.BASIS_COLUMN);
+		
+		double expectedValue = getDoubleCell(row, SS.EXPECTED_RESULT_COLUMN);
+		
+		double actualValue;
+		try {
+			actualValue = YearFracCalculator.calculate(startDate, endDate, basis);
+		} catch (EvaluationException e) {
+			throw new RuntimeException(e);
+		}
+		if (expectedValue != actualValue) {
+			throw new ComparisonFailure("Direct calculate failed - row " + (row.getRowNum()+1), 
+					String.valueOf(expectedValue), String.valueOf(actualValue));
+		}
+		actualValue = formulaEvaluator.evaluate(cell).getNumberValue();
+		if (expectedValue != actualValue) {
+			throw new ComparisonFailure("Formula evaluate failed - row " + (row.getRowNum()+1), 
+					String.valueOf(expectedValue), String.valueOf(actualValue));
+		}
+	}
+
+	private static double makeDate(HSSFRow row, int yearColumn) {
+		int year = getIntCell(row, yearColumn + 0);
+		int month = getIntCell(row, yearColumn + 1);
+		int day = getIntCell(row, yearColumn + 2);
+		Calendar c = new GregorianCalendar(year, month-1, day, 0, 0, 0);
+		c.set(Calendar.MILLISECOND, 0);
+		return HSSFDateUtil.getExcelDate(c.getTime());
+	}
+
+	private static int getIntCell(HSSFRow row, int colIx) {
+		double dVal = getDoubleCell(row, colIx);
+		if (Math.floor(dVal) != dVal) {
+			throw new RuntimeException("Non integer value (" + dVal 
+					+ ") cell found at column " + (char)('A' + colIx));
+		}
+		return (int)dVal;
+	}
+
+	private static double getDoubleCell(HSSFRow row, int colIx) {
+		HSSFCell cell = row.getCell(colIx);
+		if (cell == null) {
+			throw new RuntimeException("No cell found at column " + colIx);
+		}
+		double dVal = cell.getNumericCellValue();
+		return dVal;
+	}
+
+	/**
+	 * Useful to keep output concise when expecting many failures to be reported by this test case
+	 * TODO - refactor duplicates in other Test~FromSpreadsheet classes
+	 */
+	private static void printShortStackTrace(PrintStream ps, Throwable e) {
+		StackTraceElement[] stes = e.getStackTrace();
+		
+		int startIx = 0;
+		// skip any top frames inside junit.framework.Assert
+		while(startIx<stes.length) {
+			if(!stes[startIx].getClassName().equals(Assert.class.getName())) {
+				break;
+			}
+			startIx++;
+		}
+		// skip bottom frames (part of junit framework)
+		int endIx = startIx+1;
+		while(endIx < stes.length) {
+			if(stes[endIx].getClassName().equals(TestCase.class.getName())) {
+				break;
+			}
+			endIx++;
+		}
+		if(startIx >= endIx) {
+			// something went wrong. just print the whole stack trace
+			e.printStackTrace(ps);
+		}
+		endIx -= 4; // skip 4 frames of reflection invocation
+		ps.println(e.toString());
+		for(int i=startIx; i<endIx; i++) {
+			ps.println("\tat " + stes[i].toString());
+		}
+	}
+}

src/testcases/org/apache/poi/hssf/record/formula/function/TestReadMissingBuiltInFuncs.java

@@ -150,7 +150,7 @@ public final class TestReadMissingBuiltInFuncs extends TestCase {
 			// some other unexpected error
 			throw e;
 		}
-		String result = sheet.getRow(rowIx).getCell((short)0).getCellFormula();
+		String result = sheet.getRow(rowIx).getCell(0).getCellFormula();
 		if (false) {
 			System.err.println(result);
 		}

src/testcases/org/apache/poi/hssf/usermodel/TestCellStyle.java

@@ -85,7 +85,7 @@ public class TestCellStyle
                 c.setCellValue(rownum * 10000 + cellnum
                                + ((( double ) rownum / 1000)
                                   + (( double ) cellnum / 10000)));
-                c = r.createCell(( short ) (cellnum + 1));
+                c = r.createCell(cellnum + 1);
                 c.setCellValue("TEST");
                 c.setCellStyle(cs);
             }
@@ -112,16 +112,16 @@ public class TestCellStyle
         HSSFWorkbook     wb   = new HSSFWorkbook();
         HSSFSheet        s    = wb.createSheet();
         HSSFCellStyle    cs   = wb.createCellStyle();
-        HSSFRow row = s.createRow((short)0);
+        HSSFRow row = s.createRow(0);
 
         // with Date:
-        HSSFCell cell = row.createCell((short)1);
+        HSSFCell cell = row.createCell(1);
         cs.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy"));
         cell.setCellStyle(cs);
         cell.setCellValue(new Date());
 
         // with Calendar:
-        cell = row.createCell((short)2);
+        cell = row.createCell(2);
         cs.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy"));
         cell.setCellStyle(cs);
         Calendar cal = Calendar.getInstance();
@@ -143,9 +143,9 @@ public class TestCellStyle
         HSSFSheet        s    = wb.createSheet();
         HSSFCellStyle    cs1  = wb.createCellStyle();
         HSSFCellStyle    cs2  = wb.createCellStyle();
-        HSSFRow row = s.createRow((short)0);
+        HSSFRow row = s.createRow(0);
-        HSSFCell cell1 = row.createCell((short)1);
+        HSSFCell cell1 = row.createCell(1);
-        HSSFCell cell2 = row.createCell((short)2);
+        HSSFCell cell2 = row.createCell(2);
         
         cs1.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy"));
         cs2.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/dd/yy"));
@@ -215,7 +215,7 @@ public class TestCellStyle
                                + ((( double ) rownum / 1000)
                                   + (( double ) cellnum / 10000)));
                 c.setCellStyle(cs);
-                c = r.createCell(( short ) (cellnum + 1));
+                c = r.createCell(cellnum + 1);
                 c.setCellValue("TEST");
                 c.setCellStyle(cs2);
             }

src/testcases/org/apache/poi/hssf/usermodel/TestDataValidation.java

@@ -111,7 +111,7 @@ public final class TestDataValidation extends TestCase {
 					inputBox, errorBox);
 			if (_cellStyle != null) {
 				HSSFRow row = _sheet.getRow(_sheet.getPhysicalNumberOfRows() - 1);
-				HSSFCell cell = row.createCell((short) 0);
+				HSSFCell cell = row.createCell(0);
 				cell.setCellStyle(_cellStyle);
 			}
 			writeOtherSettings(_sheet, _style_1, promptDescr);
@@ -144,26 +144,26 @@ public final class TestDataValidation extends TestCase {
 				boolean errorBox) {
 			HSSFRow row = sheet.createRow(sheet.getPhysicalNumberOfRows());
 			// condition's string
-			HSSFCell cell = row.createCell((short) 1);
+			HSSFCell cell = row.createCell(1);
 			cell.setCellStyle(style_1);
 			setCellValue(cell, strCondition);
 			// allow empty cells
-			cell = row.createCell((short) 2);
+			cell = row.createCell(2);
 			cell.setCellStyle(style_2);
 			setCellValue(cell, ((allowEmpty) ? "yes" : "no"));
 			// show input box
-			cell = row.createCell((short) 3);
+			cell = row.createCell(3);
 			cell.setCellStyle(style_2);
 			setCellValue(cell, ((inputBox) ? "yes" : "no"));
 			// show error box
-			cell = row.createCell((short) 4);
+			cell = row.createCell(4);
 			cell.setCellStyle(style_2);
 			setCellValue(cell, ((errorBox) ? "yes" : "no"));
 		}
 		private static void writeOtherSettings(HSSFSheet sheet, HSSFCellStyle style,
 				String strStettings) {
 			HSSFRow row = sheet.getRow(sheet.getPhysicalNumberOfRows() - 1);
-			HSSFCell cell = row.createCell((short) 5);
+			HSSFCell cell = row.createCell(5);
 			cell.setCellStyle(style);
 			setCellValue(cell, strStettings);
 		}
@@ -256,7 +256,7 @@ public final class TestDataValidation extends TestCase {
 			HSSFRow row = sheet.createRow(sheet.getPhysicalNumberOfRows());
 			row = sheet.createRow(sheet.getPhysicalNumberOfRows());
 			sheet.addMergedRegion(new CellRangeAddress(sheet.getPhysicalNumberOfRows()-1, sheet.getPhysicalNumberOfRows()-1, 0, 5));
-			HSSFCell cell = row.createCell((short) 0);
+			HSSFCell cell = row.createCell(0);
 			setCellValue(cell, strTypeDescription);
 			cell.setCellStyle(_style_3);
 			row = sheet.createRow(sheet.getPhysicalNumberOfRows());
@@ -267,7 +267,7 @@ public final class TestDataValidation extends TestCase {
 			HSSFRow row = sheet.createRow(sheet.getPhysicalNumberOfRows());
 			row.setHeight((short) 400);
 			for (int i = 0; i < 6; i++) {
-				row.createCell((short) i).setCellStyle(_style_4);
+				row.createCell(i).setCellStyle(_style_4);
 				if (i == 2 || i == 3 || i == 4) {
 					sheet.setColumnWidth((short) i, (short) 3500);
 				} else if (i == 5) {
@@ -276,17 +276,17 @@ public final class TestDataValidation extends TestCase {
 					sheet.setColumnWidth((short) i, (short) 8000);
 				}
 			}
-			HSSFCell cell = row.getCell((short) 0);
+			HSSFCell cell = row.getCell(0);
 			setCellValue(cell, "Data validation cells");
-			cell = row.getCell((short) 1);
+			cell = row.getCell(1);
 			setCellValue(cell, "Condition");
-			cell = row.getCell((short) 2);
+			cell = row.getCell(2);
 			setCellValue(cell, "Allow blank");
-			cell = row.getCell((short) 3);
+			cell = row.getCell(3);
 			setCellValue(cell, "Prompt box");
-			cell = row.getCell((short) 4);
+			cell = row.getCell(4);
 			setCellValue(cell, "Error box");
-			cell = row.getCell((short) 5);
+			cell = row.getCell(5);
 			setCellValue(cell, "Other settings");
 		}
 
@@ -298,7 +298,7 @@ public final class TestDataValidation extends TestCase {
 			HSSFSheet sheet = _currentSheet;
 			HSSFRow row = sheet.getRow(sheet.getPhysicalNumberOfRows()-1);
 			sheet.addMergedRegion(new CellRangeAddress(sheet.getPhysicalNumberOfRows()-1, sheet.getPhysicalNumberOfRows()-1, 0, 5));
-			HSSFCell cell = row.createCell((short)0);
+			HSSFCell cell = row.createCell(0);
 			setCellValue(cell, strTypeDescription);
 			cell.setCellStyle(_style_3);
 			row = sheet.createRow(sheet.getPhysicalNumberOfRows());
@@ -395,14 +395,14 @@ public final class TestDataValidation extends TestCase {
 		// add list data on same sheet
 		for (int i = 0; i < 10; i++) {
 			HSSFRow currRow = fSheet.createRow(i + 29);
-			setCellValue(currRow.createCell((short) 0), cellStrValue);
+			setCellValue(currRow.createCell(0), cellStrValue);
 		}
 		// add list data on another sheet
 		for (int i = 0; i < 10; i++) {
 			HSSFRow currRow = dataSheet.createRow(i + 0);
-			setCellValue(currRow.createCell((short) 0), "Data a" + i);
+			setCellValue(currRow.createCell(0), "Data a" + i);
-			setCellValue(currRow.createCell((short) 1), "Data b" + i);
+			setCellValue(currRow.createCell(1), "Data b" + i);
-			setCellValue(currRow.createCell((short) 2), "Data c" + i);
+			setCellValue(currRow.createCell(2), "Data c" + i);
 		}
 	}
 

src/testcases/org/apache/poi/hssf/usermodel/TestFormulas.java

@@ -54,8 +54,8 @@ public final class TestFormulas extends TestCase {
         HSSFCell         c      = null;
 
         //get our minimum values
-        r = s.createRow((short)1);
+        r = s.createRow(1);
-        c = r.createCell((short)1);
+        c = r.createCell(1);
         c.setCellFormula(1 + "+" + 1);
 
         wb.write(out);
@@ -64,8 +64,8 @@ public final class TestFormulas extends TestCase {
         FileInputStream in = new FileInputStream(file);
         wb = new HSSFWorkbook(in);
         s  = wb.getSheetAt(0);
-        r  = s.getRow((short)1);
+        r  = s.getRow(1);
-        c  = r.getCell((short)1);
+        c  = r.getCell(1);
 
         assertTrue("Formula is as expected",("1+1".equals(c.getCellFormula())));
         in.close();
@@ -176,24 +176,24 @@ public final class TestFormulas extends TestCase {
 
         //get our minimum values
 
-        r = s.createRow((short)0);
+        r = s.createRow(0);
-        c = r.createCell((short)1);
+        c = r.createCell(1);
         c.setCellFormula(""+Float.MIN_VALUE + operator + Float.MIN_VALUE);
 
        for (short x = 1; x < Short.MAX_VALUE && x > 0; x=(short)(x*2) ) {
-            r = s.createRow((short) x);
+            r = s.createRow(x);
 
             for (short y = 1; y < 256 && y > 0; y= (short) (y +2)) {
 
-                c = r.createCell((short) y);
+                c = r.createCell(y);
                 c.setCellFormula("" + x+"."+y + operator + y +"."+x);
 
 
             }
         }
         if (s.getLastRowNum() < Short.MAX_VALUE) {
-            r = s.createRow((short)0);
+            r = s.createRow(0);
-            c = r.createCell((short)0);
+            c = r.createCell(0);
             c.setCellFormula("" + Float.MAX_VALUE + operator + Float.MAX_VALUE);
         }
         wb.write(out);
@@ -216,11 +216,11 @@ public final class TestFormulas extends TestCase {
         // dont know how to check correct result .. for the moment, we just verify that the file can be read.
 
         for (short x = 1; x < Short.MAX_VALUE && x > 0; x=(short)(x*2)) {
-            r = s.getRow((short) x);
+            r = s.getRow(x);
 
             for (short y = 1; y < 256 && y > 0; y=(short)(y+2)) {
 
-                c = r.getCell((short) y);
+                c = r.getCell(y);
                 assertTrue("got a formula",c.getCellFormula()!=null);
 
                 assertTrue("loop Formula is as expected "+x+"."+y+operator+y+"."+x+"!="+c.getCellFormula(),(
@@ -337,8 +337,8 @@ public final class TestFormulas extends TestCase {
         HSSFCell         c      = null;
 
         //get our minimum values
-        r = s.getRow((short)0);
+        r = s.getRow(0);
-        c = r.getCell((short)1);
+        c = r.getCell(1);
         //get our minimum values
         assertTrue("minval Formula is as expected A2"+operator+"A3 != "+c.getCellFormula(),
         ( ("A2"+operator+"A3").equals(c.getCellFormula())
@@ -346,7 +346,7 @@ public final class TestFormulas extends TestCase {
 
 
         for (short x = 1; x < Short.MAX_VALUE && x > 0; x=(short)(x*2)) {
-            r = s.getRow((short) x);
+            r = s.getRow(x);
 
             for (short y = 1; y < 256 && y > 0; y++) {
 
@@ -372,7 +372,7 @@ public final class TestFormulas extends TestCase {
                     refy2=(short)(y-3);
                 }
 
-                c = r.getCell((short) y);
+                c = r.getCell(y);
                 CellReference cr= new CellReference(refx1, refy1, false, false);
                 ref=cr.formatAsString();
                 cr=new CellReference(refx2,refy2, false, false);
@@ -389,8 +389,8 @@ public final class TestFormulas extends TestCase {
         }
 
         //test our maximum values
-        r = s.getRow((short)0);
+        r = s.getRow(0);
-        c = r.getCell((short)0);
+        c = r.getCell(0);
 
         assertTrue("maxval Formula is as expected",(
         ("B1"+operator+"IV255").equals(c.getCellFormula())
@@ -416,8 +416,8 @@ public final class TestFormulas extends TestCase {
         HSSFCell         c      = null;
 
         //get our minimum values
-        r = s.createRow((short)0);
+        r = s.createRow(0);
-        c = r.createCell((short)1);
+        c = r.createCell(1);
         c.setCellFormula(formula);
 
         wb.write(out);
@@ -429,8 +429,8 @@ public final class TestFormulas extends TestCase {
         s      = wb.getSheetAt(0);
 
         //get our minimum values
-        r = s.getRow((short)0);
+        r = s.getRow(0);
-        c = r.getCell((short)1);
+        c = r.getCell(1);
         assertTrue("minval Formula is as expected",
                    formula.equals(c.getCellFormula())
                   );
@@ -496,18 +496,18 @@ public final class TestFormulas extends TestCase {
         HSSFCell         c      = null;
 
         //get our minimum values
-        r = s.getRow((short)0);
+        r = s.getRow(0);
-        c = r.getCell((short)1);
+        c = r.getCell(1);
         assertTrue("minval Formula is as expected 1"+operator+"1 != "+c.getCellFormula(),
         ( ("1"+operator+"1").equals(c.getCellFormula())
         ));
 
         for (short x = 1; x < Short.MAX_VALUE && x > 0; x=(short)(x*2)) {
-            r = s.getRow((short) x);
+            r = s.getRow(x);
 
             for (short y = 1; y < 256 && y > 0; y++) {
 
-                c = r.getCell((short) y);
+                c = r.getCell(y);
 
                 assertTrue("loop Formula is as expected "+x+operator+y+"!="+c.getCellFormula(),(
                 (""+x+operator+y).equals(c.getCellFormula())
@@ -519,8 +519,8 @@ public final class TestFormulas extends TestCase {
         }
 
         //test our maximum values
-        r = s.getRow((short)0);
+        r = s.getRow(0);
-        c = r.getCell((short)0);
+        c = r.getCell(0);
 
 
         assertTrue("maxval Formula is as expected",(
@@ -549,9 +549,9 @@ public final class TestFormulas extends TestCase {
             HSSFCell         c      = null;
 
 
-            r = s.createRow((short) 0);
+            r = s.createRow(0);
 
-            c = r.createCell((short) 0);
+            c = r.createCell(0);
             c.setCellFormula(function+"(A2:A3)");
 
 
@@ -563,7 +563,7 @@ public final class TestFormulas extends TestCase {
             wb = new HSSFWorkbook(in);
             s = wb.getSheetAt(0);
             r = s.getRow(0);
-            c = r.getCell((short)0);
+            c = r.getCell(0);
 
             assertTrue("function ="+function+"(A2:A3)",
                         ( (function+"(A2:A3)").equals((function+"(A2:A3)")) )
@@ -586,9 +586,9 @@ public final class TestFormulas extends TestCase {
             HSSFCell         c      = null;
 
 
-            r = s.createRow((short) 0);
+            r = s.createRow(0);
 
-            c = r.createCell((short) 0);
+            c = r.createCell(0);
             c.setCellFormula(function+"(A2,A3)");
 
 
@@ -600,7 +600,7 @@ public final class TestFormulas extends TestCase {
             wb = new HSSFWorkbook(in);
             s = wb.getSheetAt(0);
             r = s.getRow(0);
-            c = r.getCell((short)0);
+            c = r.getCell(0);
 
             assertTrue("function ="+function+"(A2,A3)",
                         ( (function+"(A2,A3)").equals(c.getCellFormula()) )
@@ -624,11 +624,11 @@ public final class TestFormulas extends TestCase {
             HSSFCell         c      = null;
 
 
-            r = s.createRow((short) 0);
+            r = s.createRow(0);
 
-            c = r.createCell((short) 0);
+            c = r.createCell(0);
             c.setCellFormula(function+"(A2:A4,B2:B4)");
-            c=r.createCell((short) 1);
+            c=r.createCell(1);
             c.setCellFormula(function+"($A$2:$A4,B$2:B4)");
 
             wb.write(out);
@@ -639,13 +639,13 @@ public final class TestFormulas extends TestCase {
             wb = new HSSFWorkbook(in);
             s = wb.getSheetAt(0);
             r = s.getRow(0);
-            c = r.getCell((short)0);
+            c = r.getCell(0);
 
             assertTrue("function ="+function+"(A2:A4,B2:B4)",
                         ( (function+"(A2:A4,B2:B4)").equals(c.getCellFormula()) )
                       );
 
-            c=r.getCell((short) 1);
+            c=r.getCell(1);
              assertTrue("function ="+function+"($A$2:$A4,B$2:B4)",
                         ( (function+"($A$2:$A4,B$2:B4)").equals(c.getCellFormula()) )
                       );
@@ -663,17 +663,17 @@ public final class TestFormulas extends TestCase {
             HSSFCell         c      = null;
 
 
-            r = s.createRow((short) 0);
+            r = s.createRow(0);
 
-            c = r.createCell((short) 0);
+            c = r.createCell(0);
             c.setCellFormula("A3+A2");
-            c=r.createCell( (short) 1);
+            c=r.createCell(1);
             c.setCellFormula("$A3+$A2");
-            c=r.createCell( (short) 2);
+            c=r.createCell(2);
             c.setCellFormula("A$3+A$2");
-            c=r.createCell( (short) 3);
+            c=r.createCell(3);
             c.setCellFormula("$A$3+$A$2");
-            c=r.createCell( (short) 4);
+            c=r.createCell(4);
             c.setCellFormula("SUM($A$3,$A$2)");
 
             wb.write(out);
@@ -684,15 +684,15 @@ public final class TestFormulas extends TestCase {
             wb = new HSSFWorkbook(in);
             s = wb.getSheetAt(0);
             r = s.getRow(0);
-            c = r.getCell((short)0);
+            c = r.getCell(0);
             assertTrue("A3+A2", ("A3+A2").equals(c.getCellFormula()));
-             c = r.getCell((short)1);
+             c = r.getCell(1);
             assertTrue("$A3+$A2", ("$A3+$A2").equals(c.getCellFormula()));
-             c = r.getCell((short)2);
+             c = r.getCell(2);
             assertTrue("A$3+A$2", ("A$3+A$2").equals(c.getCellFormula()));
-             c = r.getCell((short)3);
+             c = r.getCell(3);
             assertTrue("$A$3+$A$2", ("$A$3+$A$2").equals(c.getCellFormula()));
-             c = r.getCell((short)4);
+             c = r.getCell(4);
             assertTrue("SUM($A$3,$A$2)", ("SUM($A$3,$A$2)").equals(c.getCellFormula()));
             in.close();
     }
@@ -706,15 +706,15 @@ public final class TestFormulas extends TestCase {
             HSSFSheet        s      = wb.createSheet("A");
             HSSFRow          r      = null;
             HSSFCell         c      = null;
-            r = s.createRow((short)0);
+            r = s.createRow(0);
-            c = r.createCell((short)0);c.setCellValue(1);
+            c = r.createCell(0);c.setCellValue(1);
-            c = r.createCell((short)1);c.setCellValue(2);
+            c = r.createCell(1);c.setCellValue(2);
 
             s      = wb.createSheet("B");
-            r = s.createRow((short)0);
+            r = s.createRow(0);
-            c=r.createCell((short)0); c.setCellFormula("AVERAGE(A!A1:B1)");
+            c=r.createCell(0); c.setCellFormula("AVERAGE(A!A1:B1)");
-            c=r.createCell((short)1); c.setCellFormula("A!A1+A!B1");
+            c=r.createCell(1); c.setCellFormula("A!A1+A!B1");
-            c=r.createCell((short)2); c.setCellFormula("A!$A$1+A!$B1");
+            c=r.createCell(2); c.setCellFormula("A!$A$1+A!$B1");
             wb.write(out);
             out.close();
 
@@ -724,9 +724,9 @@ public final class TestFormulas extends TestCase {
             wb = new HSSFWorkbook(in);
             s = wb.getSheet("B");
             r = s.getRow(0);
-            c = r.getCell((short)0);
+            c = r.getCell(0);
             assertTrue("expected: AVERAGE(A!A1:B1) got: "+c.getCellFormula(), ("AVERAGE(A!A1:B1)").equals(c.getCellFormula()));
-            c = r.getCell((short)1);
+            c = r.getCell(1);
             assertTrue("expected: A!A1+A!B1 got: "+c.getCellFormula(), ("A!A1+A!B1").equals(c.getCellFormula()));
             in.close();
     }
@@ -740,29 +740,29 @@ public final class TestFormulas extends TestCase {
             HSSFCell         c      = null;
 
 
-            r = s.createRow((short) 0);
+            r = s.createRow(0);
 
-            c = r.createCell((short) 0);
+            c = r.createCell(0);
             c.setCellFormula("A3+A2");
-            c=r.createCell( (short) 1);
+            c=r.createCell(1);
             c.setCellFormula("AVERAGE(A3,A2)");
-            c=r.createCell( (short) 2);
+            c=r.createCell(2);
             c.setCellFormula("ROW(A3)");
-            c=r.createCell( (short) 3);
+            c=r.createCell(3);
             c.setCellFormula("AVERAGE(A2:A3)");
-            c=r.createCell( (short) 4);
+            c=r.createCell(4);
             c.setCellFormula("POWER(A2,A3)");
-            c=r.createCell( (short) 5);
+            c=r.createCell(5);
             c.setCellFormula("SIN(A2)");
 
-            c=r.createCell( (short) 6);
+            c=r.createCell(6);
             c.setCellFormula("SUM(A2:A3)");
 
-            c=r.createCell( (short) 7);
+            c=r.createCell(7);
             c.setCellFormula("SUM(A2,A3)");
 
-            r = s.createRow((short) 1);c=r.createCell( (short) 0); c.setCellValue(2.0);
+            r = s.createRow(1);c=r.createCell(0); c.setCellValue(2.0);
-             r = s.createRow((short) 2);c=r.createCell( (short) 0); c.setCellValue(3.0);
+             r = s.createRow(2);c=r.createCell(0); c.setCellValue(3.0);
 
             wb.write(out);
             out.close();
@@ -778,10 +778,10 @@ public final class TestFormulas extends TestCase {
             HSSFSheet        s      = wb.createSheet("A");
             HSSFRow          r      = null;
             HSSFCell         c      = null;
-            r = s.createRow((short)0);
+            r = s.createRow(0);
-            c=r.createCell((short)1); c.setCellFormula("UPPER(\"abc\")");
+            c=r.createCell(1); c.setCellFormula("UPPER(\"abc\")");
-            c=r.createCell((short)2); c.setCellFormula("LOWER(\"ABC\")");
+            c=r.createCell(2); c.setCellFormula("LOWER(\"ABC\")");
-            c=r.createCell((short)3); c.setCellFormula("CONCATENATE(\" my \",\" name \")");
+            c=r.createCell(3); c.setCellFormula("CONCATENATE(\" my \",\" name \")");
 
             wb.write(out);
             out.close();
@@ -789,7 +789,7 @@ public final class TestFormulas extends TestCase {
             wb = openSample("StringFormulas.xls");
             s = wb.getSheetAt(0);
             r = s.getRow(0);
-            c = r.getCell((short)0);
+            c = r.getCell(0);
             assertTrue("expected: UPPER(\"xyz\") got "+c.getCellFormula(), ("UPPER(\"xyz\")").equals(c.getCellFormula()));
             //c = r.getCell((short)1);
             //assertTrue("expected: A!A1+A!B1 got: "+c.getCellFormula(), ("A!A1+A!B1").equals(c.getCellFormula()));
@@ -807,8 +807,8 @@ public final class TestFormulas extends TestCase {
             HSSFSheet        s      = wb.createSheet("A");
             HSSFRow          r      = null;
             HSSFCell         c      = null;
-            r = s.createRow((short)0);
+            r = s.createRow(0);
-            c=r.createCell((short)1); c.setCellFormula("IF(A1<A2,B1,B2)");
+            c=r.createCell(1); c.setCellFormula("IF(A1<A2,B1,B2)");
 
 
             wb.write(out);
@@ -820,7 +820,7 @@ public final class TestFormulas extends TestCase {
             wb = new HSSFWorkbook(in);
             s = wb.getSheetAt(0);
             r = s.getRow(0);
-            c = r.getCell((short)1);
+            c = r.getCell(1);
             assertEquals("Formula in cell 1 ","IF(A1<A2,B1,B2)",c.getCellFormula());
             in.close();
     }
@@ -835,8 +835,8 @@ public final class TestFormulas extends TestCase {
             HSSFRow          r      = null;
             HSSFCell         c      = null;
 
-            r = s.createRow(  (short)0 );
+            r = s.createRow(0 );
-            c = r.createCell( (short)0 );
+            c = r.createCell(0 );
 
             HSSFCellStyle cellStyle = wb.createCellStyle();
             cellStyle.setDataFormat(HSSFDataFormat.getBuiltinFormat("m/d/yy h:mm"));
@@ -847,8 +847,8 @@ public final class TestFormulas extends TestCase {
            //              HSSFDateUtil.getJavaDate(excelDate).getTime());
 
             for (int k=1; k < 100; k++) {
-              r=s.createRow((short)k);
+              r=s.createRow(k);
-              c=r.createCell((short)0);
+              c=r.createCell(0);
               c.setCellFormula("A"+(k)+"+1");
               c.setCellStyle(cellStyle);
             }
@@ -870,11 +870,11 @@ public final class TestFormulas extends TestCase {
             HSSFSheet        s      = wb.createSheet("testSheet1");
             HSSFRow          r      = null;
             HSSFCell         c      = null;
-            r = s.createRow((short)0);
+            r = s.createRow(0);
-            c=r.createCell((short)1); c.setCellValue(1);
+            c=r.createCell(1); c.setCellValue(1);
-            c=r.createCell((short)2); c.setCellValue(2);
+            c=r.createCell(2); c.setCellValue(2);
-            c=r.createCell((short)3); c.setCellFormula("MAX(A1:B1)");
+            c=r.createCell(3); c.setCellFormula("MAX(A1:B1)");
-            c=r.createCell((short)4); c.setCellFormula("IF(A1=D1,\"A1\",\"B1\")");
+            c=r.createCell(4); c.setCellFormula("IF(A1=D1,\"A1\",\"B1\")");
 
             wb.write(out);
             out.close();
@@ -885,7 +885,7 @@ public final class TestFormulas extends TestCase {
             wb = new HSSFWorkbook(in);
             s = wb.getSheetAt(0);
             r = s.getRow(0);
-            c = r.getCell((short)4);
+            c = r.getCell(4);
 
             assertTrue("expected: IF(A1=D1,\"A1\",\"B1\") got "+c.getCellFormula(), ("IF(A1=D1,\"A1\",\"B1\")").equals(c.getCellFormula()));
             in.close();
@@ -893,7 +893,7 @@ public final class TestFormulas extends TestCase {
             wb = openSample("IfFormulaTest.xls");
             s = wb.getSheetAt(0);
             r = s.getRow(3);
-            c = r.getCell((short)0);
+            c = r.getCell(0);
             assertTrue("expected: IF(A3=A1,\"A1\",\"A2\") got "+c.getCellFormula(), ("IF(A3=A1,\"A1\",\"A2\")").equals(c.getCellFormula()));
             //c = r.getCell((short)1);
             //assertTrue("expected: A!A1+A!B1 got: "+c.getCellFormula(), ("A!A1+A!B1").equals(c.getCellFormula()));
@@ -905,8 +905,8 @@ public final class TestFormulas extends TestCase {
         s      = wb.createSheet("testSheet1");
         r      = null;
         c      = null;
-        r = s.createRow((short)0);
+        r = s.createRow(0);
-        c=r.createCell((short)0); c.setCellFormula("IF(1=1,0,1)");
+        c=r.createCell(0); c.setCellFormula("IF(1=1,0,1)");
 
         wb.write(out);
         out.close();
@@ -920,21 +920,21 @@ public final class TestFormulas extends TestCase {
         s      = wb.createSheet("testSheet1");
         r      = null;
         c      = null;
-        r = s.createRow((short)0);
+        r = s.createRow(0);
-        c=r.createCell((short)0);
+        c=r.createCell(0);
         c.setCellValue(1);
 
-        c=r.createCell((short)1);
+        c=r.createCell(1);
         c.setCellValue(3);
 
 
-        HSSFCell formulaCell=r.createCell((short)3);
+        HSSFCell formulaCell=r.createCell(3);
 
-        r = s.createRow((short)1);
+        r = s.createRow(1);
-        c=r.createCell((short)0);
+        c=r.createCell(0);
         c.setCellValue(3);
 
-        c=r.createCell((short)1);
+        c=r.createCell(1);
         c.setCellValue(7);
 
         formulaCell.setCellFormula("IF(A1=B1,AVERAGE(A1:B1),AVERAGE(A2:B2))");
@@ -956,7 +956,7 @@ public final class TestFormulas extends TestCase {
 
         HSSFSheet        s      = wb.getSheetAt(0);
         HSSFRow          r      = s.getRow(0);
-        HSSFCell         c      = r.getCell((short)2);
+        HSSFCell         c      = r.getCell(2);
         assertEquals(function, c.getCellFormula());
 
 
@@ -965,29 +965,29 @@ public final class TestFormulas extends TestCase {
         wb     = new HSSFWorkbook();
         s      = wb.createSheet();
 
-        r = s.createRow((short)0);
+        r = s.createRow(0);
-        c=r.createCell((short)0); c.setCellValue((double)1000);
+        c=r.createCell(0); c.setCellValue((double)1000);
-        c=r.createCell((short)1); c.setCellValue((double)1);
+        c=r.createCell(1); c.setCellValue((double)1);
 
 
-        r = s.createRow((short)1);
+        r = s.createRow(1);
-        c=r.createCell((short)0); c.setCellValue((double)2000);
+        c=r.createCell(0); c.setCellValue((double)2000);
-        c=r.createCell((short)1); c.setCellValue((double)2);
+        c=r.createCell(1); c.setCellValue((double)2);
 
-        r = s.createRow((short)2);
+        r = s.createRow(2);
-        c=r.createCell((short)0); c.setCellValue((double)3000);
+        c=r.createCell(0); c.setCellValue((double)3000);
-        c=r.createCell((short)1); c.setCellValue((double)3);
+        c=r.createCell(1); c.setCellValue((double)3);
 
-        r = s.createRow((short)3);
+        r = s.createRow(3);
-        c=r.createCell((short)0); c.setCellValue((double)4000);
+        c=r.createCell(0); c.setCellValue((double)4000);
-        c=r.createCell((short)1); c.setCellValue((double)4);
+        c=r.createCell(1); c.setCellValue((double)4);
 
-        r = s.createRow((short)4);
+        r = s.createRow(4);
-        c=r.createCell((short)0); c.setCellValue((double)5000);
+        c=r.createCell(0); c.setCellValue((double)5000);
-        c=r.createCell((short)1); c.setCellValue((double)5);
+        c=r.createCell(1); c.setCellValue((double)5);
 
         r = s.getRow(0);
-        c=r.createCell((short)2); c.setCellFormula(function);
+        c=r.createCell(2); c.setCellFormula(function);
 
         wb.write(out);
         out.close();
@@ -1002,42 +1002,42 @@ public final class TestFormulas extends TestCase {
         HSSFSheet s0 = w.getSheetAt(0);
         HSSFRow[] r = {s0.getRow(0), s0.getRow(1)};
 
-        HSSFCell a1 = r[0].getCell((short) 0);
+        HSSFCell a1 = r[0].getCell(0);
         assertEquals("square(1)", a1.getCellFormula());
         assertEquals(1d, a1.getNumericCellValue(), 1e-9);
 
-        HSSFCell a2 = r[1].getCell((short) 0);
+        HSSFCell a2 = r[1].getCell(0);
         assertEquals("square(2)", a2.getCellFormula());
         assertEquals(4d, a2.getNumericCellValue(), 1e-9);
 
-        HSSFCell b1 = r[0].getCell((short) 1);
+        HSSFCell b1 = r[0].getCell(1);
         assertEquals("IF(TRUE,square(1))", b1.getCellFormula());
         assertEquals(1d, b1.getNumericCellValue(), 1e-9);
 
-        HSSFCell b2 = r[1].getCell((short) 1);
+        HSSFCell b2 = r[1].getCell(1);
         assertEquals("IF(TRUE,square(2))", b2.getCellFormula());
         assertEquals(4d, b2.getNumericCellValue(), 1e-9);
 
-        HSSFCell c1 = r[0].getCell((short) 2);
+        HSSFCell c1 = r[0].getCell(2);
         assertEquals("square(square(1))", c1.getCellFormula());
         assertEquals(1d, c1.getNumericCellValue(), 1e-9);
 
-        HSSFCell c2 = r[1].getCell((short) 2);
+        HSSFCell c2 = r[1].getCell(2);
         assertEquals("square(square(2))", c2.getCellFormula());
         assertEquals(16d, c2.getNumericCellValue(), 1e-9);
 
-        HSSFCell d1 = r[0].getCell((short) 3);
+        HSSFCell d1 = r[0].getCell(3);
         assertEquals("square(one())", d1.getCellFormula());
         assertEquals(1d, d1.getNumericCellValue(), 1e-9);
 
-        HSSFCell d2 = r[1].getCell((short) 3);
+        HSSFCell d2 = r[1].getCell(3);
         assertEquals("square(two())", d2.getCellFormula());
         assertEquals(4d, d2.getNumericCellValue(), 1e-9);
     }
 
     public void testStringFormulaRead() {
         HSSFWorkbook w = openSample("StringFormulas.xls");
-        HSSFCell c = w.getSheetAt(0).getRow(0).getCell((short)0);
+        HSSFCell c = w.getSheetAt(0).getRow(0).getCell(0);
         assertEquals("String Cell value","XYZ",c.getRichStringCellValue().getString());
     }
 
@@ -1046,8 +1046,8 @@ public final class TestFormulas extends TestCase {
          HSSFWorkbook sb = new HSSFWorkbook();
          HSSFSheet s1 = sb.createSheet("Sheet a.1");
          HSSFSheet s2 = sb.createSheet("Sheet.A");
-         s2.createRow(1).createCell((short) 2).setCellFormula("'Sheet a.1'!A1");
+         s2.createRow(1).createCell(2).setCellFormula("'Sheet a.1'!A1");
-         s1.createRow(1).createCell((short) 2).setCellFormula("'Sheet.A'!A1");
+         s1.createRow(1).createCell(2).setCellFormula("'Sheet.A'!A1");
          File file = TempFile.createTempFile("testComplexSheetRefs",".xls");
          sb.write(new FileOutputStream(file));
     }
@@ -1073,17 +1073,17 @@ public final class TestFormulas extends TestCase {
     /* MissingArgPtg */
     public void testMissingArgPtg() throws Exception {
         HSSFWorkbook wb = new HSSFWorkbook();
-        HSSFCell cell = wb.createSheet("Sheet1").createRow(4).createCell((short) 0);
+        HSSFCell cell = wb.createSheet("Sheet1").createRow(4).createCell(0);
         cell.setCellFormula("IF(A1=\"A\",1,)");
     }
 
     public void testSharedFormula() {
         HSSFWorkbook wb = openSample("SharedFormulaTest.xls");
 
-        assertEquals("A$1*2", wb.getSheetAt(0).getRow(1).getCell((short)1).toString());
+        assertEquals("A$1*2", wb.getSheetAt(0).getRow(1).getCell(1).toString());
-        assertEquals("$A11*2", wb.getSheetAt(0).getRow(11).getCell((short)1).toString());
+        assertEquals("$A11*2", wb.getSheetAt(0).getRow(11).getCell(1).toString());
-        assertEquals("DZ2*2", wb.getSheetAt(0).getRow(1).getCell((short)128).toString());
+        assertEquals("DZ2*2", wb.getSheetAt(0).getRow(1).getCell(128).toString());
-        assertEquals("B32770*2", wb.getSheetAt(0).getRow(32768).getCell((short)1).toString());
+        assertEquals("B32770*2", wb.getSheetAt(0).getRow(32768).getCell(1).toString());
     }
 
     public static void main(String [] args) {

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFCell.java

@@ -76,7 +76,7 @@ public final class TestHSSFCell extends TestCase {
         HSSFSheet        s      = wb.createSheet("testSheet1");
         HSSFRow          r      = null;
         HSSFCell         c      = null;
-        r = s.createRow((short)0);
+        r = s.createRow(0);
         c=r.createCell(1);
         //c.setCellType(HSSFCell.CELL_TYPE_BOOLEAN);
         c.setCellValue(true);
@@ -85,7 +85,7 @@ public final class TestHSSFCell extends TestCase {
         //c.setCellType(HSSFCell.CELL_TYPE_BOOLEAN);
         c.setCellValue(false);
 
-        r = s.createRow((short)1);
+        r = s.createRow(1);
         c=r.createCell(1);
         //c.setCellType(HSSFCell.CELL_TYPE_ERROR);
         c.setCellErrorValue((byte)0);
@@ -241,7 +241,7 @@ public final class TestHSSFCell extends TestCase {
             cs.setBorderLeft((short)1);
             cs.setBorderBottom((short)1);
             
-            r = s.createRow((short)0);
+            r = s.createRow(0);
             c=r.createCell(0);
             c.setCellStyle(cs);
             c.setCellFormula("2*3");

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFComment.java

@@ -116,7 +116,7 @@ public final class TestHSSFComment extends TestCase {
 
          for (int rownum = 0; rownum < 3; rownum++) {
              row = sheet.getRow(rownum);
-             cell = row.getCell((short)0);
+             cell = row.getCell(0);
              comment = cell.getCellComment();
              assertNull("Cells in the first column are not commented", comment);
              assertNull(sheet.getCellComment(rownum, 0));
@@ -124,7 +124,7 @@ public final class TestHSSFComment extends TestCase {
 
          for (int rownum = 0; rownum < 3; rownum++) {
              row = sheet.getRow(rownum);
-             cell = row.getCell((short)1);
+             cell = row.getCell(1);
              comment = cell.getCellComment();
              assertNotNull("Cells in the second column have comments", comment);
              assertNotNull("Cells in the second column have comments", sheet.getCellComment(rownum, 1));
@@ -153,7 +153,7 @@ public final class TestHSSFComment extends TestCase {
 
          for (int rownum = 0; rownum < 3; rownum++) {
              row = sheet.getRow(rownum);
-             cell = row.getCell((short)1);
+             cell = row.getCell(1);
              comment = cell.getCellComment();
              comment.setAuthor("Mofified["+rownum+"] by Yegor");
              comment.setString(new HSSFRichTextString("Modified comment at row " + rownum));
@@ -168,7 +168,7 @@ public final class TestHSSFComment extends TestCase {
 
         for (int rownum = 0; rownum < 3; rownum++) {
             row = sheet.getRow(rownum);
-            cell = row.getCell((short)1);
+            cell = row.getCell(1);
             comment = cell.getCellComment();
 
             assertEquals("Mofified["+rownum+"] by Yegor", comment.getAuthor());

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFConditionalFormatting.java

@@ -17,6 +17,7 @@
 
 package org.apache.poi.hssf.usermodel;
 
+import junit.framework.AssertionFailedError;
 import junit.framework.TestCase;
 
 import org.apache.poi.hssf.record.CFRuleRecord.ComparisonOperator;
@@ -109,4 +110,44 @@ public final class TestHSSFConditionalFormatting extends TestCase
 		assertEquals("2",rule2.getFormula2()); 
 		assertEquals("1",rule2.getFormula1()); 
 	}
+	
+	public void testClone() {
+
+		HSSFWorkbook wb = new HSSFWorkbook();
+		HSSFSheet sheet = wb.createSheet();
+		String formula = "7";
+
+		HSSFSheetConditionalFormatting sheetCF = sheet.getSheetConditionalFormatting();
+		
+		HSSFConditionalFormattingRule rule1 = sheetCF.createConditionalFormattingRule(formula);
+		HSSFFontFormatting fontFmt = rule1.createFontFormatting();
+		fontFmt.setFontStyle(true, false);
+
+		HSSFPatternFormatting patternFmt = rule1.createPatternFormatting();
+		patternFmt.setFillBackgroundColor(HSSFColor.YELLOW.index);
+
+		
+		HSSFConditionalFormattingRule rule2 = sheetCF.createConditionalFormattingRule(ComparisonOperator.BETWEEN, "1", "2");
+		HSSFConditionalFormattingRule [] cfRules =
+		{
+			rule1, rule2
+		};
+
+		short col = 1;
+		CellRangeAddress [] regions = {
+			new CellRangeAddress(0, 65535, col, col)
+		};
+
+		sheetCF.addConditionalFormatting(regions, cfRules);
+			
+		try {
+			wb.cloneSheet(0);
+		} catch (RuntimeException e) {
+			if (e.getMessage().indexOf("needs to define a clone method") > 0) {
+				throw new AssertionFailedError("Indentified bug 45682");
+			}
+			throw e;
+		}
+		assertEquals(2, wb.getNumberOfSheets());
+	}
 }

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFDateUtil.java

@@ -16,7 +16,6 @@
    limitations under the License.
 ==================================================================== */
 
-
 package org.apache.poi.hssf.usermodel;
 
 import java.util.Calendar;
@@ -52,9 +51,7 @@ public final class TestHSSFDateUtil extends TestCase {
      * Checks the date conversion functions in the HSSFDateUtil class.
      */
 
-    public void testDateConversion()
+    public void testDateConversion() {
-            throws Exception
-    {
 
         // Iteratating over the hours exposes any rounding issues.
         for (int hour = 0; hour < 23; hour++)
@@ -131,7 +128,7 @@ public final class TestHSSFDateUtil extends TestCase {
         for (int hour = 0; hour < 24; hour++, excelDate += oneHour) {
 
             // Skip 02:00 CET as that is the Daylight change time
-            // and Java converts it automatically to 03:00 CEST            
+            // and Java converts it automatically to 03:00 CEST
             if (hour == 2) {
                 continue;
             }
@@ -186,7 +183,7 @@ public final class TestHSSFDateUtil extends TestCase {
                     HSSFDateUtil.getExcelDate(javaDate, false), oneMinute);
         }
     }
-    
+
     /**
      * Tests that we deal with time-zones properly
      */
@@ -207,8 +204,7 @@ public final class TestHSSFDateUtil extends TestCase {
             assertEquals("Checking timezone " + id, expected.getTime(), javaDate.getTime());
         }
     }
-    
+
-    
     /**
      * Tests that we correctly detect date formats as such
      */
@@ -220,7 +216,7 @@ public final class TestHSSFDateUtil extends TestCase {
             assertTrue( HSSFDateUtil.isInternalDateFormat(builtins[i]) );
             assertTrue( HSSFDateUtil.isADateFormat(builtins[i],formatStr) );
         }
-        
+
         // Now try a few built-in non date formats
         builtins = new short[] { 0x01, 0x02, 0x17, 0x1f, 0x30 };
         for(int i=0; i<builtins.length; i++) {
@@ -228,14 +224,14 @@ public final class TestHSSFDateUtil extends TestCase {
             assertFalse( HSSFDateUtil.isInternalDateFormat(builtins[i]) );
             assertFalse( HSSFDateUtil.isADateFormat(builtins[i],formatStr) );
         }
-        
+
         // Now for some non-internal ones
         // These come after the real ones
         int numBuiltins = HSSFDataFormat.getNumberOfBuiltinBuiltinFormats();
         assertTrue(numBuiltins < 60);
         short formatId = 60;
         assertFalse( HSSFDateUtil.isInternalDateFormat(formatId) );
-        
+
         // Valid ones first
         String[] formats = new String[] {
                 "yyyy-mm-dd", "yyyy/mm/dd", "yy/mm/dd", "yy/mmm/dd",
@@ -243,7 +239,7 @@ public final class TestHSSFDateUtil extends TestCase {
                 "dd-mm-yy", "dd-mm-yyyy",
                 "DD-MM-YY", "DD-mm-YYYY",
                 "dd\\-mm\\-yy", // Sometimes escaped
-                
+
                 // These crazy ones are valid
                 "yyyy-mm-dd;@", "yyyy/mm/dd;@",
                 "dd-mm-yy;@", "dd-mm-yyyy;@",
@@ -257,14 +253,14 @@ public final class TestHSSFDateUtil extends TestCase {
         };
         for(int i=0; i<formats.length; i++) {
             assertTrue(
-            		formats[i] + " is a date format", 
+                    formats[i] + " is a date format",
-            		HSSFDateUtil.isADateFormat(formatId, formats[i])
+                    HSSFDateUtil.isADateFormat(formatId, formats[i])
             );
         }
-        
+
         // Then time based ones too
         formats = new String[] {
-                "yyyy-mm-dd hh:mm:ss", "yyyy/mm/dd HH:MM:SS", 
+                "yyyy-mm-dd hh:mm:ss", "yyyy/mm/dd HH:MM:SS",
                 "mm/dd HH:MM", "yy/mmm/dd SS",
                 "mm/dd HH:MM AM", "mm/dd HH:MM am",
                 "mm/dd HH:MM PM", "mm/dd HH:MM pm",
@@ -272,30 +268,30 @@ public final class TestHSSFDateUtil extends TestCase {
         };
         for(int i=0; i<formats.length; i++) {
             assertTrue(
-            		formats[i] + " is a datetime format", 
+                    formats[i] + " is a datetime format",
-            		HSSFDateUtil.isADateFormat(formatId, formats[i])
+                    HSSFDateUtil.isADateFormat(formatId, formats[i])
             );
         }
-        
+
         // Then invalid ones
         formats = new String[] {
-                "yyyy*mm*dd", 
+                "yyyy*mm*dd",
                 "0.0", "0.000",
                 "0%", "0.0%",
                 "[]Foo", "[BLACK]0.00%",
                 "", null
         };
         for(int i=0; i<formats.length; i++) {
-            assertFalse( 
+            assertFalse(
-            		formats[i] + " is not a date or datetime format",
+                    formats[i] + " is not a date or datetime format",
-            		HSSFDateUtil.isADateFormat(formatId, formats[i])
+                    HSSFDateUtil.isADateFormat(formatId, formats[i])
             );
         }
-        
+
         // And these are ones we probably shouldn't allow,
         //  but would need a better regexp
         formats = new String[] {
-                "yyyy:mm:dd", 
+                "yyyy:mm:dd",
         };
         for(int i=0; i<formats.length; i++) {
         //    assertFalse( HSSFDateUtil.isADateFormat(formatId, formats[i]) );
@@ -306,63 +302,63 @@ public final class TestHSSFDateUtil extends TestCase {
      * Test that against a real, test file, we still do everything
      *  correctly
      */
-    public void testOnARealFile() throws Exception {
+    public void testOnARealFile() {
 
         HSSFWorkbook workbook = HSSFTestDataSamples.openSampleWorkbook("DateFormats.xls");
         HSSFSheet sheet       = workbook.getSheetAt(0);
         Workbook wb           = workbook.getWorkbook();
-        
+
         HSSFRow  row;
         HSSFCell cell;
         HSSFCellStyle style;
-        
+
         double aug_10_2007 = 39304.0;
-        
+
         // Should have dates in 2nd column
         // All of them are the 10th of August
         // 2 US dates, 3 UK dates
         row  = sheet.getRow(0);
-        cell = row.getCell((short)1);
+        cell = row.getCell(1);
         style = cell.getCellStyle();
         assertEquals(aug_10_2007, cell.getNumericCellValue(), 0.0001);
         assertEquals("d-mmm-yy", style.getDataFormatString());
         assertTrue(HSSFDateUtil.isInternalDateFormat(style.getDataFormat()));
         assertTrue(HSSFDateUtil.isADateFormat(style.getDataFormat(), style.getDataFormatString()));
         assertTrue(HSSFDateUtil.isCellDateFormatted(cell));
-        
+
         row  = sheet.getRow(1);
-        cell = row.getCell((short)1);
+        cell = row.getCell(1);
         style = cell.getCellStyle();
         assertEquals(aug_10_2007, cell.getNumericCellValue(), 0.0001);
         assertFalse(HSSFDateUtil.isInternalDateFormat(cell.getCellStyle().getDataFormat()));
         assertTrue(HSSFDateUtil.isADateFormat(style.getDataFormat(), style.getDataFormatString()));
         assertTrue(HSSFDateUtil.isCellDateFormatted(cell));
-        
+
         row  = sheet.getRow(2);
-        cell = row.getCell((short)1);
+        cell = row.getCell(1);
         style = cell.getCellStyle();
         assertEquals(aug_10_2007, cell.getNumericCellValue(), 0.0001);
         assertTrue(HSSFDateUtil.isInternalDateFormat(cell.getCellStyle().getDataFormat()));
         assertTrue(HSSFDateUtil.isADateFormat(style.getDataFormat(), style.getDataFormatString()));
         assertTrue(HSSFDateUtil.isCellDateFormatted(cell));
-        
+
         row  = sheet.getRow(3);
-        cell = row.getCell((short)1);
+        cell = row.getCell(1);
         style = cell.getCellStyle();
         assertEquals(aug_10_2007, cell.getNumericCellValue(), 0.0001);
         assertFalse(HSSFDateUtil.isInternalDateFormat(cell.getCellStyle().getDataFormat()));
         assertTrue(HSSFDateUtil.isADateFormat(style.getDataFormat(), style.getDataFormatString()));
         assertTrue(HSSFDateUtil.isCellDateFormatted(cell));
-        
+
         row  = sheet.getRow(4);
-        cell = row.getCell((short)1);
+        cell = row.getCell(1);
         style = cell.getCellStyle();
         assertEquals(aug_10_2007, cell.getNumericCellValue(), 0.0001);
         assertFalse(HSSFDateUtil.isInternalDateFormat(cell.getCellStyle().getDataFormat()));
         assertTrue(HSSFDateUtil.isADateFormat(style.getDataFormat(), style.getDataFormatString()));
         assertTrue(HSSFDateUtil.isCellDateFormatted(cell));
     }
-    
+
     public void testDateBug_2Excel() {
         assertEquals(59.0, HSSFDateUtil.getExcelDate(createDate(1900, CALENDAR_FEBRUARY, 28), false), 0.00001);
         assertEquals(61.0, HSSFDateUtil.getExcelDate(createDate(1900, CALENDAR_MARCH, 1), false), 0.00001);
@@ -372,41 +368,49 @@ public final class TestHSSFDateUtil extends TestCase {
         assertEquals(37257.00, HSSFDateUtil.getExcelDate(createDate(2002, CALENDAR_JANUARY, 1), false), 0.00001);
         assertEquals(38074.00, HSSFDateUtil.getExcelDate(createDate(2004, CALENDAR_MARCH, 28), false), 0.00001);
     }
-    
+
     public void testDateBug_2Java() {
         assertEquals(createDate(1900, CALENDAR_FEBRUARY, 28), HSSFDateUtil.getJavaDate(59.0, false));
         assertEquals(createDate(1900, CALENDAR_MARCH, 1), HSSFDateUtil.getJavaDate(61.0, false));
-        
+
         assertEquals(createDate(2002, CALENDAR_FEBRUARY, 28), HSSFDateUtil.getJavaDate(37315.00, false));
         assertEquals(createDate(2002, CALENDAR_MARCH, 1), HSSFDateUtil.getJavaDate(37316.00, false));
         assertEquals(createDate(2002, CALENDAR_JANUARY, 1), HSSFDateUtil.getJavaDate(37257.00, false));
         assertEquals(createDate(2004, CALENDAR_MARCH, 28), HSSFDateUtil.getJavaDate(38074.00, false));
     }
-    
+
     public void testDate1904() {
         assertEquals(createDate(1904, CALENDAR_JANUARY, 2), HSSFDateUtil.getJavaDate(1.0, true));
         assertEquals(createDate(1904, CALENDAR_JANUARY, 1), HSSFDateUtil.getJavaDate(0.0, true));
         assertEquals(0.0, HSSFDateUtil.getExcelDate(createDate(1904, CALENDAR_JANUARY, 1), true), 0.00001);
         assertEquals(1.0, HSSFDateUtil.getExcelDate(createDate(1904, CALENDAR_JANUARY, 2), true), 0.00001);
-        
+
         assertEquals(createDate(1998, CALENDAR_JULY, 5), HSSFDateUtil.getJavaDate(35981, false));
         assertEquals(createDate(1998, CALENDAR_JULY, 5), HSSFDateUtil.getJavaDate(34519, true));
-        
+
         assertEquals(35981.0, HSSFDateUtil.getExcelDate(createDate(1998, CALENDAR_JULY, 5), false), 0.00001);
         assertEquals(34519.0, HSSFDateUtil.getExcelDate(createDate(1998, CALENDAR_JULY, 5), true), 0.00001);
     }
-    
+
     /**
-     * @param month zero based 
+     * @param month zero based
      * @param day one based
      */
     private static Date createDate(int year, int month, int day) {
+        return createDate(year, month, day, 0, 0, 0);
+    }
+
+    /**
+     * @param month zero based
+     * @param day one based
+     */
+    private static Date createDate(int year, int month, int day, int hour, int minute, int second) {
         Calendar c = new GregorianCalendar();
-        c.set(year, month, day, 0, 0, 0);
+        c.set(year, month, day, hour, minute, second);
         c.set(Calendar.MILLISECOND, 0);
         return c.getTime();
     }
-    
+
     /**
      * Check if HSSFDateUtil.getAbsoluteDay works as advertised.
      */
@@ -420,16 +424,27 @@ public final class TestHSSFDateUtil extends TestCase {
     }
 
     public void testConvertTime() {
-    	
+
         final double delta = 1E-7; // a couple of digits more accuracy than strictly required
         assertEquals(0.5, HSSFDateUtil.convertTime("12:00"), delta);
         assertEquals(2.0/3, HSSFDateUtil.convertTime("16:00"), delta);
         assertEquals(0.0000116, HSSFDateUtil.convertTime("0:00:01"), delta);
         assertEquals(0.7330440, HSSFDateUtil.convertTime("17:35:35"), delta);
     }
-    
+
     public void testParseDate() {
         assertEquals(createDate(2008, Calendar.AUGUST, 3), HSSFDateUtil.parseYYYYMMDDDate("2008/08/03"));
         assertEquals(createDate(1994, Calendar.MAY, 1), HSSFDateUtil.parseYYYYMMDDDate("1994/05/01"));
     }
+
+    /**
+     * Ensure that date values *with* a fractional portion get the right time of day
+     */
+    public void testConvertDateTime() {
+    	// Excel day 30000 is date 18-Feb-1982 
+        // 0.7 corresponds to time 16:48:00
+        Date actual = HSSFDateUtil.getJavaDate(30000.7);
+        Date expected = createDate(1982, 1, 18, 16, 48, 0);
+        assertEquals(expected, actual);
+    }
 }

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFHyperlink.java

@@ -42,14 +42,14 @@ public final class TestHSSFHyperlink extends TestCase {
         HSSFHyperlink link;
 
         sheet = wb.getSheet("WebLinks");
-        cell = sheet.getRow(4).getCell((short)0);
+        cell = sheet.getRow(4).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("POI", link.getLabel());
         assertEquals("POI", cell.getRichStringCellValue().getString());
         assertEquals("http://poi.apache.org/", link.getAddress());
 
-        cell = sheet.getRow(8).getCell((short)0);
+        cell = sheet.getRow(8).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("HSSF", link.getLabel());
@@ -57,7 +57,7 @@ public final class TestHSSFHyperlink extends TestCase {
         assertEquals("http://poi.apache.org/hssf/", link.getAddress());
 
         sheet = wb.getSheet("Emails");
-        cell = sheet.getRow(4).getCell((short)0);
+        cell = sheet.getRow(4).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("dev", link.getLabel());
@@ -65,7 +65,7 @@ public final class TestHSSFHyperlink extends TestCase {
         assertEquals("mailto:dev@poi.apache.org", link.getAddress());
 
         sheet = wb.getSheet("Internal");
-        cell = sheet.getRow(4).getCell((short)0);
+        cell = sheet.getRow(4).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("Link To First Sheet", link.getLabel());
@@ -81,7 +81,7 @@ public final class TestHSSFHyperlink extends TestCase {
         HSSFHyperlink link;
 
         sheet = wb.getSheet("WebLinks");
-        cell = sheet.getRow(4).getCell((short)0);
+        cell = sheet.getRow(4).getCell(0);
         link = cell.getHyperlink();
         //modify the link
         link.setAddress("www.apache.org");
@@ -92,7 +92,7 @@ public final class TestHSSFHyperlink extends TestCase {
 
         wb = new HSSFWorkbook(new ByteArrayInputStream(out.toByteArray()));
         sheet = wb.getSheet("WebLinks");
-        cell = sheet.getRow(4).getCell((short)0);
+        cell = sheet.getRow(4).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("www.apache.org", link.getAddress());
@@ -106,21 +106,21 @@ public final class TestHSSFHyperlink extends TestCase {
         HSSFSheet sheet = wb.createSheet("Hyperlinks");
 
         //URL
-        cell = sheet.createRow(0).createCell((short)0);
+        cell = sheet.createRow(0).createCell(0);
         cell.setCellValue("URL Link");
         HSSFHyperlink link = new HSSFHyperlink(HSSFHyperlink.LINK_URL);
         link.setAddress("http://poi.apache.org/");
         cell.setHyperlink(link);
 
         //link to a file in the current directory
-        cell = sheet.createRow(1).createCell((short)0);
+        cell = sheet.createRow(1).createCell(0);
         cell.setCellValue("File Link");
         link = new HSSFHyperlink(HSSFHyperlink.LINK_FILE);
         link.setAddress("link1.xls");
         cell.setHyperlink(link);
 
         //e-mail link
-        cell = sheet.createRow(2).createCell((short)0);
+        cell = sheet.createRow(2).createCell(0);
         cell.setCellValue("Email Link");
         link = new HSSFHyperlink(HSSFHyperlink.LINK_EMAIL);
         //note, if subject contains white spaces, make sure they are url-encoded
@@ -131,9 +131,9 @@ public final class TestHSSFHyperlink extends TestCase {
 
         //create a target sheet and cell
         HSSFSheet sheet2 = wb.createSheet("Target Sheet");
-        sheet2.createRow(0).createCell((short)0).setCellValue("Target Cell");
+        sheet2.createRow(0).createCell(0).setCellValue("Target Cell");
 
-        cell = sheet.createRow(3).createCell((short)0);
+        cell = sheet.createRow(3).createCell(0);
         cell.setCellValue("Worksheet Link");
         link = new HSSFHyperlink(HSSFHyperlink.LINK_DOCUMENT);
         link.setAddress("'Target Sheet'!A1");
@@ -145,22 +145,22 @@ public final class TestHSSFHyperlink extends TestCase {
 
         wb = new HSSFWorkbook(new ByteArrayInputStream(out.toByteArray()));
         sheet = wb.getSheet("Hyperlinks");
-        cell = sheet.getRow(0).getCell((short)0);
+        cell = sheet.getRow(0).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("http://poi.apache.org/", link.getAddress());
 
-        cell = sheet.getRow(1).getCell((short)0);
+        cell = sheet.getRow(1).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("link1.xls", link.getAddress());
 
-        cell = sheet.getRow(2).getCell((short)0);
+        cell = sheet.getRow(2).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("mailto:poi@apache.org?subject=Hyperlinks", link.getAddress());
 
-        cell = sheet.getRow(3).getCell((short)0);
+        cell = sheet.getRow(3).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("'Target Sheet'!A1", link.getAddress());
@@ -174,12 +174,12 @@ public final class TestHSSFHyperlink extends TestCase {
 
         HSSFSheet sheet = wb.cloneSheet(0);
 
-        cell = sheet.getRow(4).getCell((short)0);
+        cell = sheet.getRow(4).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("http://poi.apache.org/", link.getAddress());
 
-        cell = sheet.getRow(8).getCell((short)0);
+        cell = sheet.getRow(8).getCell(0);
         link = cell.getHyperlink();
         assertNotNull(link);
         assertEquals("http://poi.apache.org/hssf/", link.getAddress());

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFOptimiser.java

@@ -107,13 +107,13 @@ public class TestHSSFOptimiser extends TestCase {
 		HSSFRichTextString rtr1 = new HSSFRichTextString("Test");
 		rtr1.applyFont(0, 2, f1);
 		rtr1.applyFont(3, 4, f2);
-		r.createCell((short)0).setCellValue(rtr1);
+		r.createCell(0).setCellValue(rtr1);
 		
 		HSSFRichTextString rtr2 = new HSSFRichTextString("AlsoTest");
 		rtr2.applyFont(0, 2, f3);
 		rtr2.applyFont(3, 5, f5);
 		rtr2.applyFont(6, 8, f6);
-		r.createCell((short)1).setCellValue(rtr2);
+		r.createCell(1).setCellValue(rtr2);
 		
 		
 		// Check what we have now
@@ -198,14 +198,14 @@ public class TestHSSFOptimiser extends TestCase {
 		HSSFSheet s = wb.createSheet();
 		HSSFRow r = s.createRow(0);
 		
-		r.createCell((short)0).setCellStyle(cs1);
+		r.createCell(0).setCellStyle(cs1);
-		r.createCell((short)1).setCellStyle(cs2);
+		r.createCell(1).setCellStyle(cs2);
-		r.createCell((short)2).setCellStyle(cs3);
+		r.createCell(2).setCellStyle(cs3);
-		r.createCell((short)3).setCellStyle(cs4);
+		r.createCell(3).setCellStyle(cs4);
-		r.createCell((short)4).setCellStyle(cs5);
+		r.createCell(4).setCellStyle(cs5);
-		r.createCell((short)5).setCellStyle(cs6);
+		r.createCell(5).setCellStyle(cs6);
-		r.createCell((short)6).setCellStyle(cs1);
+		r.createCell(6).setCellStyle(cs1);
-		r.createCell((short)7).setCellStyle(cs2);
+		r.createCell(7).setCellStyle(cs2);
 		
 		assertEquals(21, r.getCell(0).getCellValueRecord().getXFIndex());
 		assertEquals(26, r.getCell(5).getCellValueRecord().getXFIndex());

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFPalette.java

@@ -94,11 +94,11 @@ public final class TestHSSFPalette extends TestCase {
         
         HSSFPalette p = book.getCustomPalette();
         
-        HSSFCell cellA = book.getSheetAt(0).getRow(0).getCell((short)0);
+        HSSFCell cellA = book.getSheetAt(0).getRow(0).getCell(0);
-        HSSFCell cellB = book.getSheetAt(0).getRow(1).getCell((short)0);
+        HSSFCell cellB = book.getSheetAt(0).getRow(1).getCell(0);
-        HSSFCell cellC = book.getSheetAt(0).getRow(2).getCell((short)0);
+        HSSFCell cellC = book.getSheetAt(0).getRow(2).getCell(0);
-        HSSFCell cellD = book.getSheetAt(0).getRow(3).getCell((short)0);
+        HSSFCell cellD = book.getSheetAt(0).getRow(3).getCell(0);
-        HSSFCell cellE = book.getSheetAt(0).getRow(4).getCell((short)0);
+        HSSFCell cellE = book.getSheetAt(0).getRow(4).getCell(0);
         
         // Plain
         assertEquals("I'm plain", cellA.getStringCellValue());

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFRow.java

@@ -36,16 +36,16 @@ public final class TestHSSFRow extends TestCase {
         assertEquals(-1, row.getFirstCellNum());
         assertEquals(-1, row.getLastCellNum());
 
-        row.createCell((short) 2);
+        row.createCell(2);
         assertEquals(2, row.getFirstCellNum());
         assertEquals(3, row.getLastCellNum());
 
-        row.createCell((short) 1);
+        row.createCell(1);
         assertEquals(1, row.getFirstCellNum());
         assertEquals(3, row.getLastCellNum());
 
         // check the exact case reported in 'bug' 43901 - notice that the cellNum is '0' based
-        row.createCell((short) 3);
+        row.createCell(3);
         assertEquals(1, row.getFirstCellNum());
         assertEquals(4, row.getLastCellNum());
     }
@@ -59,20 +59,20 @@ public final class TestHSSFRow extends TestCase {
         HSSFSheet sheet = workbook.createSheet();
         HSSFRow rowA = sheet.createRow(0);
 
-        rowA.createCell((short) 10);
+        rowA.createCell(10);
-        rowA.createCell((short) 5);
+        rowA.createCell(5);
         assertEquals(5, rowA.getFirstCellNum());
         assertEquals(11, rowA.getLastCellNum());
 
         HSSFRow rowB = sheet.createRow(1);
-        rowB.createCell((short) 15);
+        rowB.createCell(15);
-        rowB.createCell((short) 30);
+        rowB.createCell(30);
         assertEquals(15, rowB.getFirstCellNum());
         assertEquals(31, rowB.getLastCellNum());
 
         assertEquals(5, rowA.getFirstCellNum());
         assertEquals(11, rowA.getLastCellNum());
-        rowA.createCell((short) 50);
+        rowA.createCell(50);
         assertEquals(51, rowA.getLastCellNum());
 
         assertEquals(31, rowB.getLastCellNum());
@@ -81,19 +81,19 @@ public final class TestHSSFRow extends TestCase {
     public void testRemoveCell() {
         HSSFWorkbook workbook = new HSSFWorkbook();
         HSSFSheet sheet = workbook.createSheet();
-        HSSFRow row = sheet.createRow((short) 0);
+        HSSFRow row = sheet.createRow(0);
         assertEquals(-1, row.getLastCellNum());
         assertEquals(-1, row.getFirstCellNum());
-        row.createCell((short) 1);
+        row.createCell(1);
         assertEquals(2, row.getLastCellNum());
         assertEquals(1, row.getFirstCellNum());
-        row.createCell((short) 3);
+        row.createCell(3);
         assertEquals(4, row.getLastCellNum());
         assertEquals(1, row.getFirstCellNum());
-        row.removeCell(row.getCell((short) 3));
+        row.removeCell(row.getCell(3));
         assertEquals(2, row.getLastCellNum());
         assertEquals(1, row.getFirstCellNum());
-        row.removeCell(row.getCell((short) 1));
+        row.removeCell(row.getCell(1));
         assertEquals(-1, row.getLastCellNum());
         assertEquals(-1, row.getFirstCellNum());
 
@@ -114,18 +114,18 @@ public final class TestHSSFRow extends TestCase {
     public void testMoveCell() {
         HSSFWorkbook workbook = new HSSFWorkbook();
         HSSFSheet sheet = workbook.createSheet();
-        HSSFRow row = sheet.createRow((short) 0);
+        HSSFRow row = sheet.createRow(0);
-        HSSFRow rowB = sheet.createRow((short) 1);
+        HSSFRow rowB = sheet.createRow(1);
 
-        HSSFCell cellA2 = rowB.createCell((short)0);
+        HSSFCell cellA2 = rowB.createCell(0);
         assertEquals(0, rowB.getFirstCellNum());
         assertEquals(0, rowB.getFirstCellNum());
 
         assertEquals(-1, row.getLastCellNum());
         assertEquals(-1, row.getFirstCellNum());
-        HSSFCell cellB2 = row.createCell((short) 1);
+        HSSFCell cellB2 = row.createCell(1);
-        HSSFCell cellB3 = row.createCell((short) 2);
+        HSSFCell cellB3 = row.createCell(2);
-        HSSFCell cellB4 = row.createCell((short) 3);
+        HSSFCell cellB4 = row.createCell(3);
 
         assertEquals(1, row.getFirstCellNum());
         assertEquals(4, row.getLastCellNum());
@@ -147,10 +147,10 @@ public final class TestHSSFRow extends TestCase {
         }
 
         // Move somewhere spare
-        assertNotNull(row.getCell((short)1));
+        assertNotNull(row.getCell(1));
         row.moveCell(cellB2, (short)5);
-        assertNull(row.getCell((short)1));
+        assertNull(row.getCell(1));
-        assertNotNull(row.getCell((short)5));
+        assertNotNull(row.getCell(5));
 
         assertEquals(5, cellB2.getCellNum());
         assertEquals(2, row.getFirstCellNum());
@@ -161,7 +161,7 @@ public final class TestHSSFRow extends TestCase {
       HSSFWorkbook workbook = new HSSFWorkbook();
       HSSFSheet sheet = workbook.createSheet();
       //Test low row bound
-      sheet.createRow( (short) 0);
+      sheet.createRow(0);
       //Test low row bound exception
       try {
         sheet.createRow(-1);
@@ -200,9 +200,9 @@ public final class TestHSSFRow extends TestCase {
 
         // Create two cells, will return one higher
         //  than that for the last number
-        row.createCell((short) 0);
+        row.createCell(0);
         assertEquals(1, row.getLastCellNum());
-        row.createCell((short) 255);
+        row.createCell(255);
         assertEquals(256, row.getLastCellNum());
     }
     
@@ -220,10 +220,10 @@ public final class TestHSSFRow extends TestCase {
         // 3 missing
         // 4 -> blank
         // 5 -> num
-        row.createCell((short)0).setCellValue(new HSSFRichTextString("test"));
+        row.createCell(0).setCellValue(new HSSFRichTextString("test"));
-        row.createCell((short)1).setCellValue(3.2);
+        row.createCell(1).setCellValue(3.2);
-        row.createCell((short)4, HSSFCell.CELL_TYPE_BLANK);
+        row.createCell(4, HSSFCell.CELL_TYPE_BLANK);
-        row.createCell((short)5).setCellValue(4);
+        row.createCell(5).setCellValue(4);
         
         // First up, no policy given, uses default
         assertEquals(HSSFCell.CELL_TYPE_STRING,  row.getCell(0).getCellType());
@@ -281,12 +281,12 @@ public final class TestHSSFRow extends TestCase {
     public void testRowHeight() {
         HSSFWorkbook workbook = new HSSFWorkbook();
         HSSFSheet sheet = workbook.createSheet();
-        HSSFRow row1 = sheet.createRow( (short) 0);
+        HSSFRow row1 = sheet.createRow(0);
 
         assertEquals(0xFF, row1.getHeight());
         assertEquals(sheet.getDefaultRowHeight(), row1.getHeight());
 
-        HSSFRow row2 = sheet.createRow( (short) 1);
+        HSSFRow row2 = sheet.createRow(1);
         row2.setHeight((short)400);
 
         assertEquals(400, row2.getHeight());

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFSheet.java

@@ -147,10 +147,10 @@ public final class TestHSSFSheet extends TestCase {
 	public void testReadBooleans() {
 		HSSFWorkbook workbook = new HSSFWorkbook();
 		HSSFSheet sheet = workbook.createSheet("Test boolean");
-		HSSFRow row = sheet.createRow((short) 2);
+		HSSFRow row = sheet.createRow(2);
-		HSSFCell cell = row.createCell((short) 9);
+		HSSFCell cell = row.createCell(9);
 		cell.setCellValue(true);
-		cell = row.createCell((short) 11);
+		cell = row.createCell(11);
 		cell.setCellValue(true);
 		
 		workbook = HSSFTestDataSamples.writeOutAndReadBack(workbook);
@@ -164,7 +164,7 @@ public final class TestHSSFSheet extends TestCase {
 	public void testRemoveRow() {
 		HSSFWorkbook workbook = new HSSFWorkbook();
 		HSSFSheet sheet = workbook.createSheet("Test boolean");
-		HSSFRow row = sheet.createRow((short) 2);
+		HSSFRow row = sheet.createRow(2);
 		sheet.removeRow(row);
 	}
 
@@ -186,8 +186,8 @@ public final class TestHSSFSheet extends TestCase {
 		HSSFWorkbook workbook = new HSSFWorkbook();
 		HSSFSheet sheet = workbook.createSheet("Test Clone");
 		HSSFRow row = sheet.createRow(0);
-		HSSFCell cell = row.createCell((short) 0);
+		HSSFCell cell = row.createCell(0);
-		HSSFCell cell2 = row.createCell((short) 1);
+		HSSFCell cell2 = row.createCell(1);
 		cell.setCellValue(new HSSFRichTextString("clone_test"));
 		cell2.setCellFormula("sin(1)");
 
@@ -216,8 +216,8 @@ public final class TestHSSFSheet extends TestCase {
 	public void testCloneSheetMultipleTimes() {
 		HSSFWorkbook workbook = new HSSFWorkbook();
 		HSSFSheet sheet = workbook.createSheet("Test Clone");
-		HSSFRow row = sheet.createRow((short) 0);
+		HSSFRow row = sheet.createRow(0);
-		HSSFCell cell = row.createCell((short) 0);
+		HSSFCell cell = row.createCell(0);
 		cell.setCellValue(new HSSFRichTextString("clone_test"));
 		//Clone the sheet multiple times
 		workbook.cloneSheet(0);
@@ -510,11 +510,11 @@ public final class TestHSSFSheet extends TestCase {
 		HSSFWorkbook wb = new HSSFWorkbook();
 		HSSFSheet sheet = wb.createSheet();
 		HSSFRow row = sheet.createRow(0);
-		HSSFCell cell = row.createCell((short)0);
+		HSSFCell cell = row.createCell(0);
 		cell.setCellValue(new HSSFRichTextString("first row, first cell"));
 
 		row = sheet.createRow(1);
-		cell = row.createCell((short)1);
+		cell = row.createCell(1);
 		cell.setCellValue(new HSSFRichTextString("second row, second cell"));
 
 		CellRangeAddress region = new CellRangeAddress(1, 1, 0, 1);
@@ -617,13 +617,13 @@ public final class TestHSSFSheet extends TestCase {
 		HSSFWorkbook wb = new HSSFWorkbook();
 		HSSFSheet s = wb.createSheet("Sheet1");
 		HSSFRow r = s.createRow(0);
-		r.createCell((short) 0).setCellValue(1);
+		r.createCell(0).setCellValue(1);
-		r.createCell((short) 1).setCellFormula("A1*2");
+		r.createCell(1).setCellFormula("A1*2");
 		HSSFSheet s1 = wb.cloneSheet(0);
 		r = s1.getRow(0);
-		assertEquals("double", r.getCell((short) 0).getNumericCellValue(), 1, 0); // sanity check
+		assertEquals("double", r.getCell(0).getNumericCellValue(), 1, 0); // sanity check
-		assertNotNull(r.getCell((short) 1));
+		assertNotNull(r.getCell(1));
-		assertEquals("formula", r.getCell((short) 1).getCellFormula(), "A1*2");
+		assertEquals("formula", r.getCell(1).getCellFormula(), "A1*2");
 	}
 
 	/** test that new default column styles get applied */
@@ -633,7 +633,7 @@ public final class TestHSSFSheet extends TestCase {
 		HSSFSheet s = wb.createSheet();
 		s.setDefaultColumnStyle((short) 0, style);
 		HSSFRow r = s.createRow(0);
-		HSSFCell c = r.createCell((short) 0);
+		HSSFCell c = r.createCell(0);
 		assertEquals("style should match", style.getIndex(), c.getCellStyle().getIndex());
 	}
 
@@ -710,8 +710,8 @@ public final class TestHSSFSheet extends TestCase {
 		HSSFSheet sheet = workbook.getSheetAt(0);
 		HSSFSheet sheet2 = workbook.getSheetAt(0);
 		HSSFRow row = sheet.getRow(0);
-		row.createCell((short) 0).setCellValue(5);
+		row.createCell(0).setCellValue(5);
-		row.createCell((short) 1).setCellValue(8);
+		row.createCell(1).setCellValue(8);
 		assertFalse(sheet.getForceFormulaRecalculation());
 		assertFalse(sheet2.getForceFormulaRecalculation());
 

src/testcases/org/apache/poi/hssf/usermodel/TestHSSFWorkbook.java

@@ -290,10 +290,10 @@ public final class TestHSSFWorkbook extends TestCase {
         assertEquals(true, sheet3.isActive());
 
         if (false) { // helpful if viewing this workbook in excel:
-            sheet1.createRow(0).createCell((short)0).setCellValue(new HSSFRichTextString("Sheet1"));
+            sheet1.createRow(0).createCell(0).setCellValue(new HSSFRichTextString("Sheet1"));
-            sheet2.createRow(0).createCell((short)0).setCellValue(new HSSFRichTextString("Sheet2"));
+            sheet2.createRow(0).createCell(0).setCellValue(new HSSFRichTextString("Sheet2"));
-            sheet3.createRow(0).createCell((short)0).setCellValue(new HSSFRichTextString("Sheet3"));
+            sheet3.createRow(0).createCell(0).setCellValue(new HSSFRichTextString("Sheet3"));
-            sheet4.createRow(0).createCell((short)0).setCellValue(new HSSFRichTextString("Sheet4"));
+            sheet4.createRow(0).createCell(0).setCellValue(new HSSFRichTextString("Sheet4"));
 
             try {
                 File fOut = TempFile.createTempFile("sheetMultiSelect", ".xls");

src/testcases/org/apache/poi/hssf/usermodel/TestReadWriteChart.java

@@ -39,14 +39,14 @@ public final class TestReadWriteChart extends TestCase {
         HSSFWorkbook workbook  = HSSFTestDataSamples.openSampleWorkbook("SimpleChart.xls");
         HSSFSheet       sheet     = workbook.getSheetAt(0);
         HSSFRow         firstRow  = sheet.getRow(0);
-        HSSFCell        firstCell = firstRow.getCell(( short ) 0);
+        HSSFCell        firstCell = firstRow.getCell(0);
 
         //System.out.println("first assertion for date");
         assertEquals(new GregorianCalendar(2000, 0, 1, 10, 51, 2).getTime(),
                      HSSFDateUtil
                          .getJavaDate(firstCell.getNumericCellValue(), false));
-        HSSFRow  row  = sheet.createRow(( short ) 15);
+        HSSFRow  row  = sheet.createRow(15);
-        HSSFCell cell = row.createCell(( short ) 1);
+        HSSFCell cell = row.createCell(1);
 
         cell.setCellValue(22);
         Sheet newSheet = workbook.getSheetAt(0).getSheet();

src/testcases/org/apache/poi/hssf/usermodel/TestSheetHiding.java

@@ -61,10 +61,10 @@ public final class TestSheetHiding extends TestCase {
 		assertEquals(1, wbU.getSheetAt(1).getRow(0).getLastCellNum());
 
 		// Text should be sheet based
-		assertEquals("Sheet1A1", wbH.getSheetAt(0).getRow(0).getCell((short)0).getRichStringCellValue().getString());
+		assertEquals("Sheet1A1", wbH.getSheetAt(0).getRow(0).getCell(0).getRichStringCellValue().getString());
-		assertEquals("Sheet2A1", wbH.getSheetAt(1).getRow(0).getCell((short)0).getRichStringCellValue().getString());
+		assertEquals("Sheet2A1", wbH.getSheetAt(1).getRow(0).getCell(0).getRichStringCellValue().getString());
-		assertEquals("Sheet1A1", wbU.getSheetAt(0).getRow(0).getCell((short)0).getRichStringCellValue().getString());
+		assertEquals("Sheet1A1", wbU.getSheetAt(0).getRow(0).getCell(0).getRichStringCellValue().getString());
-		assertEquals("Sheet2A1", wbU.getSheetAt(1).getRow(0).getCell((short)0).getRichStringCellValue().getString());
+		assertEquals("Sheet2A1", wbU.getSheetAt(1).getRow(0).getCell(0).getRichStringCellValue().getString());
 	}
 
 	/**

src/testcases/org/apache/poi/hssf/usermodel/TestSheetShiftRows.java

@@ -99,8 +99,8 @@ public final class TestSheetShiftRows extends TestCase {
     public void testShiftRow(){
        HSSFWorkbook b = new HSSFWorkbook();
        HSSFSheet s    = b.createSheet();
-       s.createRow(0).createCell((short)0).setCellValue("TEST1");
+       s.createRow(0).createCell(0).setCellValue("TEST1");
-       s.createRow(3).createCell((short)0).setCellValue("TEST2");
+       s.createRow(3).createCell(0).setCellValue("TEST2");
        s.shiftRows(0,4,1);
     }
 
@@ -112,8 +112,8 @@ public final class TestSheetShiftRows extends TestCase {
     public void testShiftRow0(){
        HSSFWorkbook b = new HSSFWorkbook();
        HSSFSheet s    = b.createSheet();
-       s.createRow(0).createCell((short)0).setCellValue("TEST1");
+       s.createRow(0).createCell(0).setCellValue("TEST1");
-       s.createRow(3).createCell((short)0).setCellValue("TEST2");
+       s.createRow(3).createCell(0).setCellValue("TEST2");
        s.shiftRows(0,4,1);
     }
 
@@ -125,7 +125,7 @@ public final class TestSheetShiftRows extends TestCase {
       HSSFWorkbook b = new HSSFWorkbook();
       HSSFSheet s    = b.createSheet();
       HSSFRow row = s.createRow(4);
-      row.createCell((short)0).setCellValue("test");
+      row.createCell(0).setCellValue("test");
       s.setRowBreak(4);
 
       s.shiftRows(4, 4, 2);
@@ -203,34 +203,34 @@ public final class TestSheetShiftRows extends TestCase {
         HSSFSheet sheet = wb.getSheet("Sheet1");
         assertEquals(19, sheet.getLastRowNum());
 
-        assertEquals("cell B1 (ref)", sheet.getRow(0).getCell((short)3).getRichStringCellValue().toString());
+        assertEquals("cell B1 (ref)", sheet.getRow(0).getCell(3).getRichStringCellValue().toString());
-        assertEquals("CONCATENATE(B1,\" (ref)\")", sheet.getRow(0).getCell((short)3).getCellFormula());
+        assertEquals("CONCATENATE(B1,\" (ref)\")", sheet.getRow(0).getCell(3).getCellFormula());
-        assertEquals("cell B2 (ref)", sheet.getRow(1).getCell((short)3).getRichStringCellValue().toString());
+        assertEquals("cell B2 (ref)", sheet.getRow(1).getCell(3).getRichStringCellValue().toString());
-        assertEquals("CONCATENATE(B2,\" (ref)\")", sheet.getRow(1).getCell((short)3).getCellFormula());
+        assertEquals("CONCATENATE(B2,\" (ref)\")", sheet.getRow(1).getCell(3).getCellFormula());
-        assertEquals("cell B3 (ref)", sheet.getRow(2).getCell((short)3).getRichStringCellValue().toString());
+        assertEquals("cell B3 (ref)", sheet.getRow(2).getCell(3).getRichStringCellValue().toString());
-        assertEquals("CONCATENATE(B3,\" (ref)\")", sheet.getRow(2).getCell((short)3).getCellFormula());
+        assertEquals("CONCATENATE(B3,\" (ref)\")", sheet.getRow(2).getCell(3).getCellFormula());
-        assertEquals("cell B2 (ref)", sheet.getRow(6).getCell((short)1).getRichStringCellValue().toString());
+        assertEquals("cell B2 (ref)", sheet.getRow(6).getCell(1).getRichStringCellValue().toString());
-        assertEquals("CONCATENATE(B2,\" (ref)\")", sheet.getRow(6).getCell((short)1).getCellFormula());
+        assertEquals("CONCATENATE(B2,\" (ref)\")", sheet.getRow(6).getCell(1).getCellFormula());
 
         sheet.shiftRows(1, 1, 10);
 
         // Row 1 => Row 11
         // So strings on row 11 unchanged, but reference in formula is
-        assertEquals("cell B1 (ref)", sheet.getRow(0).getCell((short)3).getRichStringCellValue().toString());
+        assertEquals("cell B1 (ref)", sheet.getRow(0).getCell(3).getRichStringCellValue().toString());
-        assertEquals("CONCATENATE(B1,\" (ref)\")", sheet.getRow(0).getCell((short)3).getCellFormula());
+        assertEquals("CONCATENATE(B1,\" (ref)\")", sheet.getRow(0).getCell(3).getCellFormula());
         assertEquals(0, sheet.getRow(1).getPhysicalNumberOfCells());
 
         // still save b2
-        assertEquals("cell B2 (ref)", sheet.getRow(11).getCell((short)3).getRichStringCellValue().toString());
+        assertEquals("cell B2 (ref)", sheet.getRow(11).getCell(3).getRichStringCellValue().toString());
         // but points to b12
-        assertEquals("CONCATENATE(B12,\" (ref)\")", sheet.getRow(11).getCell((short)3).getCellFormula());
+        assertEquals("CONCATENATE(B12,\" (ref)\")", sheet.getRow(11).getCell(3).getCellFormula());
 
-        assertEquals("cell B3 (ref)", sheet.getRow(2).getCell((short)3).getRichStringCellValue().toString());
+        assertEquals("cell B3 (ref)", sheet.getRow(2).getCell(3).getRichStringCellValue().toString());
-        assertEquals("CONCATENATE(B3,\" (ref)\")", sheet.getRow(2).getCell((short)3).getCellFormula());
+        assertEquals("CONCATENATE(B3,\" (ref)\")", sheet.getRow(2).getCell(3).getCellFormula());
 
         // one on a non-shifted row also updated
-        assertEquals("cell B2 (ref)", sheet.getRow(6).getCell((short)1).getRichStringCellValue().toString());
+        assertEquals("cell B2 (ref)", sheet.getRow(6).getCell(1).getRichStringCellValue().toString());
-        assertEquals("CONCATENATE(B12,\" (ref)\")", sheet.getRow(6).getCell((short)1).getCellFormula());
+        assertEquals("CONCATENATE(B12,\" (ref)\")", sheet.getRow(6).getCell(1).getCellFormula());
     }
 }
 

src/testcases/org/apache/poi/hssf/usermodel/TestUnicodeWorkbook.java

@@ -57,14 +57,14 @@ public class TestUnicodeWorkbook extends TestCase {
         f.setRight("\u20ac");                
 
         HSSFRow r = s.createRow(0);
-        HSSFCell c = r.createCell((short)1);
+        HSSFCell c = r.createCell(1);
         c.setCellValue(12.34);
         c.getCellStyle().setDataFormat(fmt);
         
-        HSSFCell c2 = r.createCell((short)2);
+        HSSFCell c2 = r.createCell(2);
         c.setCellValue(new HSSFRichTextString("\u20ac"));
 
-        HSSFCell c3 = r.createCell((short)3);
+        HSSFCell c3 = r.createCell(3);
         String formulaString = "TEXT(12.34,\"\u20ac###,##\")";
         c3.setCellFormula(formulaString);
 
@@ -95,16 +95,16 @@ public class TestUnicodeWorkbook extends TestCase {
 
         //Test the dataformat
         r = s.getRow(0);
-        c = r.getCell((short)1);
+        c = r.getCell(1);
         df = wb.createDataFormat();
         assertEquals(formatStr, df.getFormat(c.getCellStyle().getDataFormat()));
         
         //Test the cell string value
-        c2 = r.getCell((short)2);
+        c2 = r.getCell(2);
         assertEquals(c.getRichStringCellValue().getString(), "\u20ac");
         
         //Test the cell formula
-        c3 = r.getCell((short)3);
+        c3 = r.getCell(3);
         assertEquals(c3.getCellFormula(), formulaString);
     }
     
@@ -122,7 +122,7 @@ public class TestUnicodeWorkbook extends TestCase {
         HSSFSheet s = wb.createSheet("test");
         
         HSSFRow r = s.createRow(0);
-        HSSFCell c = r.createCell((short)1);
+        HSSFCell c = r.createCell(1);
         c.setCellValue(new HSSFRichTextString("\u00e4"));
         
         //Confirm that the sring will be compressed
@@ -140,7 +140,7 @@ public class TestUnicodeWorkbook extends TestCase {
         s = wb.getSheet("test");
         assertNotNull(s);
         
-        c = r.getCell((short)1);
+        c = r.getCell(1);
         assertEquals(c.getRichStringCellValue().getString(), "\u00e4");
     }    
 

src/testcases/org/apache/poi/hssf/usermodel/TestWorkbook.java

@@ -96,7 +96,7 @@ public final class TestWorkbook extends TestCase {
                 c.setCellValue(rownum * 10000 + cellnum
                                + ((( double ) rownum / 1000)
                                   + (( double ) cellnum / 10000)));
-                c = r.createCell(( short ) (cellnum + 1));
+                c = r.createCell(cellnum + 1);
                 c.setCellValue(new HSSFRichTextString("TEST"));
             }
         }
@@ -142,7 +142,7 @@ public final class TestWorkbook extends TestCase {
                 c.setCellValue(rownum * 10000 + cellnum
                                + ((( double ) rownum / 1000)
                                   + (( double ) cellnum / 10000)));
-                c = r.createCell(( short ) (cellnum + 1));
+                c = r.createCell(cellnum + 1);
                 c.setCellValue(new HSSFRichTextString("TEST"));
             }
         }
@@ -226,8 +226,8 @@ public final class TestWorkbook extends TestCase {
     short df = format.getFormat("0.0");
     cs.setDataFormat(df);
 
-    r = s.createRow((short)0);
+    r = s.createRow(0);
-    c = r.createCell((short)0);
+    c = r.createCell(0);
     c.setCellStyle(cs);
     c.setCellValue(1.25);
 
@@ -239,7 +239,7 @@ public final class TestWorkbook extends TestCase {
         HSSFWorkbook    workbook = new HSSFWorkbook(fs);
         HSSFSheet       sheet    = workbook.getSheetAt(0);
     HSSFCell    cell     =
-                     sheet.getRow(( short ) 0).getCell(( short ) 0);
+                     sheet.getRow(0).getCell(0);
     format = workbook.createDataFormat();
 
         assertEquals(1.25,cell.getNumericCellValue(), 1e-10);
@@ -350,7 +350,7 @@ public final class TestWorkbook extends TestCase {
 
         for (int k = 0; k < 4; k++)
         {
-            HSSFCell cell = sheet.getRow(( short ) k).getCell(( short ) 0);
+            HSSFCell cell = sheet.getRow(k).getCell(0);
 
             cell.setCellValue(new HSSFRichTextString(REPLACED));
         }
@@ -360,7 +360,7 @@ public final class TestWorkbook extends TestCase {
         sheet    = workbook.getSheetAt(0);
         for (int k = 0; k < 4; k++)
         {
-            HSSFCell cell = sheet.getRow(( short ) k).getCell(( short ) 0);
+            HSSFCell cell = sheet.getRow(k).getCell(0);
 
             assertEquals(REPLACED, cell.getRichStringCellValue().getString());
         }
@@ -439,7 +439,7 @@ public final class TestWorkbook extends TestCase {
                 c.setCellValue(rownum * 10000 + cellnum
                                + ((( double ) rownum / 1000)
                                   + (( double ) cellnum / 10000)));
-                c = r.createCell(( short ) (cellnum + 1));
+                c = r.createCell(cellnum + 1);
                 c.setCellValue(new HSSFRichTextString("TEST"));
             }
         }
@@ -530,7 +530,7 @@ public final class TestWorkbook extends TestCase {
         for ( i = 0, j = 32771; j > 0; i++, j-- )
         {
             row = sheet.createRow(i);
-            cell = row.createCell((short) 0);
+            cell = row.createCell(0);
             cell.setCellValue(i);
         }
         sanityChecker.checkHSSFWorkbook(workbook);
@@ -556,7 +556,7 @@ public final class TestWorkbook extends TestCase {
 
         HSSFRow row = sheet.createRow(0);
 
-        HSSFCell cell = row.createCell((short)1);
+        HSSFCell cell = row.createCell(1);
         cell.setCellValue(new HSSFRichTextString("hi"));