Support for freezepanes / split panes / header rows and columns on printouts... see documentation for details.

git-svn-id: https://svn.apache.org/repos/asf/jakarta/poi/trunk@353002 13f79535-47bb-0310-9956-ffa450edef68

4 files changed, 425 insertions, 11 deletions

diff --git a/src/testcases/org/apache/poi/hssf/usermodel/SanityChecker.java b/src/testcases/org/apache/poi/hssf/usermodel/SanityChecker.java
index b8974c85a0..ced4113ce0 100644
--- a/src/testcases/org/apache/poi/hssf/usermodel/SanityChecker.java
+++ b/src/testcases/org/apache/poi/hssf/usermodel/SanityChecker.java
@@ -58,7 +58,6 @@ import junit.framework.Assert;
 import org.apache.poi.hssf.model.Sheet;
 import org.apache.poi.hssf.model.Workbook;
 import org.apache.poi.hssf.record.*;
-import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 
 import java.util.List;
 
@@ -68,15 +67,27 @@ import java.util.List;
 public class SanityChecker
         extends Assert
 {
-    private class CheckRecord
+    static class CheckRecord
     {
         Class record;
-        char occurance;  // 1 = one time, M = many times
+        char occurance;  // 1 = one time, M = 1..many times, * = 0..many, 0 = optional
+        private boolean together;
 
-        public CheckRecord(Class record, char occurance)
+        public CheckRecord( Class record, char occurance )
+        {
+            this(record, occurance, true);
+        }
+
+        /**
+         * @param record        The record type to check
+         * @param occurance     The occurance 1 = occurs once, M = occurs many times
+         * @param together
+         */
+        public CheckRecord(Class record, char occurance, boolean together)
         {
             this.record = record;
             this.occurance = occurance;
+            this.together = together;
         }
 
         public Class getRecord()
@@ -88,6 +99,96 @@ public class SanityChecker
         {
             return occurance;
         }
+
+        public boolean isRequired()
+        {
+            return occurance == '1' || occurance == 'M';
+        }
+
+        public boolean isOptional()
+        {
+            return occurance == '0' || occurance == '*';
+        }
+
+        public boolean isTogether()
+        {
+            return together;
+        }
+
+        public boolean isMany()
+        {
+            return occurance == '*' || occurance == 'M';
+        }
+
+        public int match( List records, int recordIdx )
+        {
+            int firstRecord = findFirstRecord(records, getRecord(), recordIdx);
+            if (isRequired())
+            {
+                return matchRequired( firstRecord, records, recordIdx );
+            }
+            else
+            {
+                return matchOptional( firstRecord, records, recordIdx );
+            }
+        }
+
+        private int matchOptional( int firstRecord, List records, int recordIdx )
+        {
+            if (firstRecord == -1)
+            {
+                return recordIdx;
+            }
+
+            return matchOneOrMany( records, firstRecord );
+//            return matchOneOrMany( records, recordIdx );
+        }
+
+        private int matchRequired( int firstRecord, List records, int recordIdx )
+        {
+            if (firstRecord == -1)
+            {
+                fail("Manditory record missing or out of order: " + record);
+            }
+
+            return matchOneOrMany( records, firstRecord );
+//            return matchOneOrMany( records, recordIdx );
+        }
+
+        private int matchOneOrMany( List records, int recordIdx )
+        {
+            if (isZeroOrOne())
+            {
+                // check no other records
+                if (findFirstRecord(records, getRecord(), recordIdx+1) != -1)
+                    fail("More than one record matched for " + getRecord().getName());
+            }
+            else if (isZeroToMany())
+            {
+                if (together)
+                {
+                    int nextIdx = findFirstRecord(records, record, recordIdx+1);
+                    while (nextIdx != -1)
+                    {
+                        if (nextIdx - 1 != recordIdx)
+                            fail("Records are not together " + record.getName());
+                        recordIdx = nextIdx;
+                        nextIdx = findFirstRecord(records, record, recordIdx+1);
+                    }
+                }
+            }
+            return recordIdx+1;
+        }
+
+        private boolean isZeroToMany()
+        {
+            return occurance == '*' || occurance == 'M';
+        }
+
+        private boolean isZeroOrOne()
+        {
+            return occurance == '0' || occurance == '1';
+        }
     }
 
     CheckRecord[] workbookRecords = new CheckRecord[] {
@@ -115,8 +216,11 @@ public class SanityChecker
         new CheckRecord(ExtendedFormatRecord.class, 'M'),
         new CheckRecord(StyleRecord.class, 'M'),
         new CheckRecord(UseSelFSRecord.class, '1'),
-        new CheckRecord(BoundSheetRecord.class, '1'),   // Is this right?
+        new CheckRecord(BoundSheetRecord.class, 'M'),
         new CheckRecord(CountryRecord.class, '1'),
+        new CheckRecord(SupBookRecord.class, '0'),
+        new CheckRecord(ExternSheetRecord.class, '0'),
+        new CheckRecord(NameRecord.class, '*'),
         new CheckRecord(SSTRecord.class, '1'),
         new CheckRecord(ExtSSTRecord.class, '1'),
         new CheckRecord(EOFRecord.class, '1'),
@@ -147,22 +251,24 @@ public class SanityChecker
         new CheckRecord(EOFRecord.class, '1')
     };
 
-    public void checkWorkbookRecords(Workbook workbook)
+    private void checkWorkbookRecords(Workbook workbook)
     {
         List records = workbook.getRecords();
         assertTrue(records.get(0) instanceof BOFRecord);
         assertTrue(records.get(records.size() - 1) instanceof EOFRecord);
 
         checkRecordOrder(records, workbookRecords);
+//        checkRecordsTogether(records, workbookRecords);
     }
 
-    public void checkSheetRecords(Sheet sheet)
+    private void checkSheetRecords(Sheet sheet)
     {
         List records = sheet.getRecords();
         assertTrue(records.get(0) instanceof BOFRecord);
         assertTrue(records.get(records.size() - 1) instanceof EOFRecord);
 
         checkRecordOrder(records, sheetRecords);
+//        checkRecordsTogether(records, sheetRecords);
     }
 
     public void checkHSSFWorkbook(HSSFWorkbook wb)
@@ -173,7 +279,63 @@ public class SanityChecker
 
     }
 
-    private void checkRecordOrder(List records, CheckRecord[] check)
+    /*
+    private void checkRecordsTogether(List records, CheckRecord[] check)
+    {
+        for ( int checkIdx = 0; checkIdx < check.length; checkIdx++ )
+        {
+            int recordIdx = findFirstRecord(records, check[checkIdx].getRecord());
+            boolean notFoundAndRecordRequired = (recordIdx == -1 && check[checkIdx].isRequired());
+            if (notFoundAndRecordRequired)
+            {
+                fail("Expected to find record of class " + check.getClass() + " but did not");
+            }
+            else if (recordIdx >= 0)
+            {
+                if (check[checkIdx].isMany())
+                {
+                    // Skip records that are together
+                    while (recordIdx < records.size() && check[checkIdx].getRecord().isInstance(records.get(recordIdx)))
+                        recordIdx++;
+                }
+
+                // Make sure record does not occur in remaining records (after the next)
+                recordIdx++;
+                for (int recordIdx2 = recordIdx; recordIdx2 < records.size(); recordIdx2++)
+                {
+                    if (check[checkIdx].getRecord().isInstance(records.get(recordIdx2)))
+                        fail("Record occurs scattered throughout record chain:\n" + records.get(recordIdx2));
+                }
+            }
+        }
+    } */
+
+    private static int findFirstRecord( List records, Class record, int startIndex )
+    {
+        for (int i = startIndex; i < records.size(); i++)
+        {
+            if (record.getName().equals(records.get(i).getClass().getName()))
+                return i;
+        }
+        return -1;
+    }
+
+//    private static int findFirstRecord( List records, Class record )
+//    {
+//        return findFirstRecord ( records, record, 0 );
+//    }
+
+    void checkRecordOrder(List records, CheckRecord[] check)
+    {
+        int recordIdx = 0;
+        for ( int checkIdx = 0; checkIdx < check.length; checkIdx++ )
+        {
+            recordIdx = check[checkIdx].match(records, recordIdx);
+        }
+    }
+
+    /*
+    void checkRecordOrder(List records, CheckRecord[] check)
     {
         int checkIndex = 0;
         for (int recordIndex = 0; recordIndex < records.size(); recordIndex++)
@@ -186,13 +348,30 @@ public class SanityChecker
                     // skip over duplicate records if multiples are allowed
                     while (recordIndex+1 < records.size() && check[checkIndex].getRecord().isInstance(records.get(recordIndex+1)))
                         recordIndex++;
+//                    lastGoodMatch = recordIndex;
+                }
+                else if (check[checkIndex].getOccurance() == '1')
+                {
+                    // Check next record to make sure there's not more than one
+                    if (recordIndex != records.size() - 1)
+                    {
+                        if (check[checkIndex].getRecord().isInstance(records.get(recordIndex+1)))
+                        {
+                            fail("More than one occurance of record found:\n" + records.get(recordIndex).toString());
+                        }
+                    }
+//                    lastGoodMatch = recordIndex;
                 }
+//                else if (check[checkIndex].getOccurance() == '0')
+//                {
+//
+//                }
                 checkIndex++;
             }
             if (checkIndex >= check.length)
                 return;
         }
         fail("Could not find required record: " + check[checkIndex]);
-    }
+    } */
 
 }
diff --git a/src/testcases/org/apache/poi/hssf/usermodel/TestHSSFSheet.java b/src/testcases/org/apache/poi/hssf/usermodel/TestHSSFSheet.java
index 27aa0e24fa..0b39b345e5 100644
--- a/src/testcases/org/apache/poi/hssf/usermodel/TestHSSFSheet.java
+++ b/src/testcases/org/apache/poi/hssf/usermodel/TestHSSFSheet.java
@@ -59,6 +59,8 @@ import org.apache.poi.hssf.model.Sheet;
 import org.apache.poi.hssf.record.HCenterRecord;
 import org.apache.poi.hssf.record.VCenterRecord;
 import org.apache.poi.hssf.record.WSBoolRecord;
+import org.apache.poi.hssf.record.SCLRecord;
+import org.apache.poi.hssf.record.WindowTwoRecord;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -69,7 +71,6 @@ import java.io.FileOutputStream;
  *
  *
  * @author Glen Stampoultzis (glens at apache.org)
- * @version %I%, %G%
  */
 
 public class TestHSSFSheet
@@ -318,4 +319,22 @@ public class TestHSSFSheet
         assertTrue( s.getRow( 3 ) == null || s.getRow( 3 ).getPhysicalNumberOfCells() == 0 );
         assertEquals( s.getRow( 4 ).getPhysicalNumberOfCells(), 5 );
     }
+
+    public void testZoom()
+            throws Exception
+    {
+        HSSFWorkbook wb = new HSSFWorkbook();
+        HSSFSheet sheet = wb.createSheet();
+        assertEquals(-1, sheet.getSheet().findFirstRecordLocBySid(SCLRecord.sid));
+        sheet.setZoom(3,4);
+        assertTrue(sheet.getSheet().findFirstRecordLocBySid(SCLRecord.sid) > 0);
+        SCLRecord sclRecord = (SCLRecord) sheet.getSheet().findFirstRecordBySid(SCLRecord.sid);
+        assertEquals(3, sclRecord.getNumerator());
+        assertEquals(4, sclRecord.getDenominator());
+
+        int sclLoc = sheet.getSheet().findFirstRecordLocBySid(SCLRecord.sid);
+        int window2Loc = sheet.getSheet().findFirstRecordLocBySid(WindowTwoRecord.sid);
+        assertTrue(sclLoc == window2Loc + 1);
+
+    }
 }
diff --git a/src/testcases/org/apache/poi/hssf/usermodel/TestNamedRange.java b/src/testcases/org/apache/poi/hssf/usermodel/TestNamedRange.java
index c55a851826..3f76ec7ba3 100644
--- a/src/testcases/org/apache/poi/hssf/usermodel/TestNamedRange.java
+++ b/src/testcases/org/apache/poi/hssf/usermodel/TestNamedRange.java
@@ -89,7 +89,11 @@ public class TestNamedRange
         sheetName = namedRange1.getSheetName();
         //Getting its reference
         String referece = namedRange1.getReference();
-                               
+
+        // sanity check
+        SanityChecker c = new SanityChecker();
+        c.checkHSSFWorkbook(wb);
+
         File             file = File.createTempFile("testNamedRange",
                                         ".xls");
 
diff --git a/src/testcases/org/apache/poi/hssf/usermodel/TestSanityChecker.java b/src/testcases/org/apache/poi/hssf/usermodel/TestSanityChecker.java
new file mode 100644
index 0000000000..dcdedbca01
--- /dev/null
+++ b/src/testcases/org/apache/poi/hssf/usermodel/TestSanityChecker.java
@@ -0,0 +1,212 @@
+/* ====================================================================
+ * The Apache Software License, Version 1.1
+ *
+ * Copyright (c) 2002 The Apache Software Foundation.  All rights
+ * reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * 3. The end-user documentation included with the redistribution,
+ *    if any, must include the following acknowledgment:
+ *       "This product includes software developed by the
+ *        Apache Software Foundation (http://www.apache.org/)."
+ *    Alternately, this acknowledgment may appear in the software itself,
+ *    if and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Apache" and "Apache Software Foundation" and
+ *    "Apache POI" must not be used to endorse or promote products
+ *    derived from this software without prior written permission. For
+ *    written permission, please contact apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache",
+ *    "Apache POI", nor may "Apache" appear in their name, without
+ *    prior written permission of the Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
+ * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ * ====================================================================
+ *
+ * This software consists of voluntary contributions made by many
+ * individuals on behalf of the Apache Software Foundation.  For more
+ * information on the Apache Software Foundation, please see
+ * <http://www.apache.org/>.
+ */
+package org.apache.poi.hssf.usermodel;
+
+import junit.framework.TestCase;
+import junit.framework.AssertionFailedError;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import org.apache.poi.hssf.record.*;
+
+/**
+ * Okay, this may seem strange but I need to test my test logic.
+ *
+ * @author Glen Stampoultzis (glens at apache.org)
+ */
+public class TestSanityChecker
+        extends TestCase
+{
+    public TestSanityChecker( String s )
+    {
+        super( s );
+    }
+
+    public void testCheckRecordOrder()
+            throws Exception
+    {
+        final SanityChecker c = new SanityChecker();
+        List records = new ArrayList();
+        records.add(new BOFRecord());
+        records.add(new InterfaceHdrRecord());
+        records.add(new BoundSheetRecord());
+        records.add(new EOFRecord());
+        final SanityChecker.CheckRecord[] check = {
+            new SanityChecker.CheckRecord(BOFRecord.class, '1'),
+            new SanityChecker.CheckRecord(InterfaceHdrRecord.class, '0'),
+            new SanityChecker.CheckRecord(BoundSheetRecord.class, 'M'),
+            new SanityChecker.CheckRecord(NameRecord.class, '*'),
+            new SanityChecker.CheckRecord(EOFRecord.class, '1'),
+        };
+        // check pass
+        c.checkRecordOrder(records, check);
+        records.add(2, new BoundSheetRecord());
+        c.checkRecordOrder(records, check);
+        records.remove(1);      // optional record missing
+        c.checkRecordOrder(records, check);
+        records.add(3, new NameRecord());
+        records.add(3, new NameRecord()); // optional multiple record occurs more than one time
+        c.checkRecordOrder(records, check);
+
+        // check fail
+        expectFail( new Runnable() {
+            public void run()
+            {
+                // check optional in wrong spot
+                List records = new ArrayList();
+                records.add(new BOFRecord());
+                records.add(new BoundSheetRecord());
+                records.add(new InterfaceHdrRecord());
+                records.add(new EOFRecord());
+                c.checkRecordOrder(records, check);
+            }
+        });
+
+        expectFail( new Runnable() {
+            public void run()
+            {
+                // check optional one off occurs more than once
+                List records = new ArrayList();
+                records.add(new BOFRecord());
+                records.add(new InterfaceHdrRecord());
+                records.add(new BoundSheetRecord());
+                records.add(new InterfaceHdrRecord());
+                records.add(new EOFRecord());
+                c.checkRecordOrder(records, check);
+            }
+        });
+
+        expectFail( new Runnable() {
+            public void run()
+            {
+                // check many scattered
+                List records = new ArrayList();
+                records.add(new BOFRecord());
+                records.add(new BoundSheetRecord());
+                records.add(new NameRecord());
+                records.add(new EOFRecord());
+                records.add(new NameRecord());
+                c.checkRecordOrder(records, check);
+            }
+        });
+
+        expectFail( new Runnable() {
+            public void run()
+            {
+                // check missing manditory
+                List records = new ArrayList();
+                records.add(new InterfaceHdrRecord());
+                records.add(new BoundSheetRecord());
+                records.add(new EOFRecord());
+                c.checkRecordOrder(records, check);
+            }
+        });
+
+        expectFail( new Runnable() {
+            public void run()
+            {
+                // check missing 1..many
+                List records = new ArrayList();
+                records.add(new BOFRecord());
+                records.add(new InterfaceHdrRecord());
+                records.add(new EOFRecord());
+                c.checkRecordOrder(records, check);
+            }
+        });
+
+        expectFail( new Runnable() {
+            public void run()
+            {
+                // check wrong order
+                List records = new ArrayList();
+                records.add(new InterfaceHdrRecord());
+                records.add(new BoundSheetRecord());
+                records.add(new BOFRecord());
+                records.add(new EOFRecord());
+                c.checkRecordOrder(records, check);
+            }
+        });
+
+        expectFail( new Runnable() {
+            public void run()
+            {
+                // check optional record in wrong order
+                List records = new ArrayList();
+                records.add(new BOFRecord());
+                records.add(new BoundSheetRecord());
+                records.add(new InterfaceHdrRecord());
+                records.add(new EOFRecord());
+                c.checkRecordOrder(records, check);
+            }
+        });
+
+    }
+
+    private void expectFail( Runnable runnable )
+    {
+        boolean fail = false;
+        try
+        {
+            runnable.run();
+            fail = true;
+        }
+        catch (AssertionFailedError pass)
+        {
+        }
+        assertTrue(!fail);
+    }
+
+}
+