Move the missing record aware eventusermodel code out of scratchpad

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

1 files changed, 360 insertions, 0 deletions

diff --git a/src/testcases/org/apache/poi/hssf/eventusermodel/TestMissingRecordAwareHSSFListener.java b/src/testcases/org/apache/poi/hssf/eventusermodel/TestMissingRecordAwareHSSFListener.java
new file mode 100644
index 0000000000..a038a964ee
--- /dev/null
+++ b/src/testcases/org/apache/poi/hssf/eventusermodel/TestMissingRecordAwareHSSFListener.java
@@ -0,0 +1,360 @@
+/* ====================================================================
+   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.eventusermodel;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import junit.framework.TestCase;
+
+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.LabelSSTRecord;
+import org.apache.poi.hssf.record.Record;
+import org.apache.poi.hssf.record.RowRecord;
+import org.apache.poi.poifs.filesystem.POIFSFileSystem;
+/**
+ * Tests for MissingRecordAwareHSSFListener
+ */
+public final class TestMissingRecordAwareHSSFListener extends TestCase {
+	
+	private Record[] r;
+
+	public void setUp() {
+		String dirname = System.getProperty("HSSF.testdata.path");
+		File f = new File(dirname + "/MissingBits.xls");
+
+		HSSFRequest req = new HSSFRequest();
+		MockHSSFListener mockListen = new MockHSSFListener();
+		MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(mockListen);
+		req.addListenerForAllRecords(listener);
+		
+		HSSFEventFactory factory = new HSSFEventFactory();
+		try {
+			POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(f));
+			factory.processWorkbookEvents(req, fs);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+		r = mockListen.getRecords();
+	} 
+	
+	public void testMissingRowRecords() throws Exception {
+		
+		// We have rows 0, 1, 2, 20 and 21
+		int row0 = -1;
+		for(int i=0; i<r.length; i++) {
+			if(r[i] instanceof RowRecord) {
+				RowRecord rr = (RowRecord)r[i];
+				if(rr.getRowNumber() == 0) { row0 = i; }
+			}
+		}
+		assertTrue(row0 > -1);
+		
+		// Following row 0, we should have 1, 2, then dummy, then 20+21+22
+		assertTrue(r[row0] instanceof RowRecord);
+		assertTrue(r[row0+1] instanceof RowRecord);
+		assertTrue(r[row0+2] instanceof RowRecord);
+		assertTrue(r[row0+3] instanceof MissingRowDummyRecord);
+		assertTrue(r[row0+4] instanceof MissingRowDummyRecord);
+		assertTrue(r[row0+5] instanceof MissingRowDummyRecord);
+		assertTrue(r[row0+6] instanceof MissingRowDummyRecord);
+		// ...
+		assertTrue(r[row0+18] instanceof MissingRowDummyRecord);
+		assertTrue(r[row0+19] instanceof MissingRowDummyRecord);
+		assertTrue(r[row0+20] instanceof RowRecord);
+		assertTrue(r[row0+21] instanceof RowRecord);
+		assertTrue(r[row0+22] instanceof RowRecord);
+		
+		// Check things had the right row numbers
+		RowRecord rr;
+		rr = (RowRecord)r[row0+2];
+		assertEquals(2, rr.getRowNumber());
+		rr = (RowRecord)r[row0+20];
+		assertEquals(20, rr.getRowNumber());
+		rr = (RowRecord)r[row0+21];
+		assertEquals(21, rr.getRowNumber());
+		
+		MissingRowDummyRecord mr;
+		mr = (MissingRowDummyRecord)r[row0+3];
+		assertEquals(3, mr.getRowNumber());
+		mr = (MissingRowDummyRecord)r[row0+4];
+		assertEquals(4, mr.getRowNumber());
+		mr = (MissingRowDummyRecord)r[row0+5];
+		assertEquals(5, mr.getRowNumber());
+		mr = (MissingRowDummyRecord)r[row0+18];
+		assertEquals(18, mr.getRowNumber());
+		mr = (MissingRowDummyRecord)r[row0+19];
+		assertEquals(19, mr.getRowNumber());
+	}
+	
+	public void testEndOfRowRecords() throws Exception {
+		
+		// Find the cell at 0,0
+		int cell00 = -1;
+		for(int i=0; i<r.length; i++) {
+			if(r[i] instanceof LabelSSTRecord) {
+				LabelSSTRecord lr = (LabelSSTRecord)r[i];
+				if(lr.getRow() == 0 && lr.getColumn() == 0) { cell00 = i; }
+			}
+		}
+		assertTrue(cell00 > -1);
+		
+		// We have rows 0, 1, 2, 20 and 21
+		// Row 0 has 1 entry
+		// Row 1 has 4 entries
+		// Row 2 has 6 entries
+		// Row 20 has 5 entries
+		// Row 21 has 7 entries
+		// Row 22 has 12 entries
+
+		// Row 0
+		assertFalse(r[cell00+0] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+1] instanceof LastCellOfRowDummyRecord);
+		// Row 1
+		assertFalse(r[cell00+2] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+3] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+4] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+5] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+6] instanceof LastCellOfRowDummyRecord);
+		// Row 2
+		assertFalse(r[cell00+7] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+8] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+9] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+10] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+11] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+12] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+13] instanceof LastCellOfRowDummyRecord);
+		// Row 3 -> 19
+		assertTrue(r[cell00+14] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+15] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+16] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+17] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+18] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+19] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+20] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+21] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+22] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+23] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+24] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+25] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+26] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+27] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+28] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+29] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+30] instanceof LastCellOfRowDummyRecord);
+		// Row 20
+		assertFalse(r[cell00+31] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+32] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+33] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+34] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+35] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+36] instanceof LastCellOfRowDummyRecord);
+		// Row 21
+		assertFalse(r[cell00+37] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+38] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+39] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+40] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+41] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+42] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+43] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+44] instanceof LastCellOfRowDummyRecord);
+		// Row 22
+		assertFalse(r[cell00+45] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+46] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+47] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+48] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+49] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+50] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+51] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+52] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+53] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+54] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+55] instanceof LastCellOfRowDummyRecord);
+		assertFalse(r[cell00+56] instanceof LastCellOfRowDummyRecord);
+		assertTrue(r[cell00+57] instanceof LastCellOfRowDummyRecord);
+		
+		// Check the numbers of the last seen columns
+		LastCellOfRowDummyRecord[] lrs = new LastCellOfRowDummyRecord[23];
+		int lrscount = 0;
+		for(int i=0; i<r.length; i++) {
+			if(r[i] instanceof LastCellOfRowDummyRecord) {
+				lrs[lrscount] = (LastCellOfRowDummyRecord)r[i];
+				lrscount++;
+			}
+		}
+		
+		assertEquals(0, lrs[0].getLastColumnNumber());
+		assertEquals(0, lrs[0].getRow());
+		
+		assertEquals(3, lrs[1].getLastColumnNumber());
+		assertEquals(1, lrs[1].getRow());
+		
+		assertEquals(5, lrs[2].getLastColumnNumber());
+		assertEquals(2, lrs[2].getRow());
+		
+		for(int i=3; i<=19; i++) {
+			assertEquals(-1, lrs[i].getLastColumnNumber());
+			assertEquals(i, lrs[i].getRow());
+		}
+		
+		assertEquals(4, lrs[20].getLastColumnNumber());
+		assertEquals(20, lrs[20].getRow());
+		
+		assertEquals(6, lrs[21].getLastColumnNumber());
+		assertEquals(21, lrs[21].getRow());
+		
+		assertEquals(11, lrs[22].getLastColumnNumber());
+		assertEquals(22, lrs[22].getRow());
+	}
+	
+	
+	public void testMissingCellRecords() throws Exception {
+		
+		// Find the cell at 0,0
+		int cell00 = -1;
+		for(int i=0; i<r.length; i++) {
+			if(r[i] instanceof LabelSSTRecord) {
+				LabelSSTRecord lr = (LabelSSTRecord)r[i];
+				if(lr.getRow() == 0 && lr.getColumn() == 0) { cell00 = i; }
+			}
+		}
+		assertTrue(cell00 > -1);
+		
+		// We have rows 0, 1, 2, 20 and 21
+		// Row 0 has 1 entry, 0
+		// Row 1 has 4 entries, 0+3
+		// Row 2 has 6 entries, 0+5
+		// Row 20 has 5 entries, 0-5
+		// Row 21 has 7 entries, 0+1+3+5+6
+		// Row 22 has 12 entries, 0+3+4+11
+		
+		// Row 0
+		assertFalse(r[cell00+0] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+1] instanceof MissingCellDummyRecord);
+		
+		// Row 1
+		assertFalse(r[cell00+2] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+3] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+4] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+5] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+6] instanceof MissingCellDummyRecord);
+		
+		// Row 2
+		assertFalse(r[cell00+7] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+8] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+9] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+10] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+11] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+12] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+13] instanceof MissingCellDummyRecord);
+		
+		// Row 3-19
+		assertFalse(r[cell00+14] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+15] instanceof MissingCellDummyRecord);
+		
+		// Row 20
+		assertFalse(r[cell00+31] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+32] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+33] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+34] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+35] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+36] instanceof MissingCellDummyRecord);
+		
+		// Row 21
+		assertFalse(r[cell00+37] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+38] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+39] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+40] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+41] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+42] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+43] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+44] instanceof MissingCellDummyRecord);
+		
+		// Row 22
+		assertFalse(r[cell00+45] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+46] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+47] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+48] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+49] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+50] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+51] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+52] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+53] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+54] instanceof MissingCellDummyRecord);
+		assertTrue(r[cell00+55] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+56] instanceof MissingCellDummyRecord);
+		assertFalse(r[cell00+57] instanceof MissingCellDummyRecord);
+		
+		// Check some numbers
+		MissingCellDummyRecord mc;
+		
+		mc = (MissingCellDummyRecord)r[cell00+3];
+		assertEquals(1, mc.getRow());
+		assertEquals(1, mc.getColumn());
+		mc = (MissingCellDummyRecord)r[cell00+4];
+		assertEquals(1, mc.getRow());
+		assertEquals(2, mc.getColumn());
+		
+		mc = (MissingCellDummyRecord)r[cell00+8];
+		assertEquals(2, mc.getRow());
+		assertEquals(1, mc.getColumn());
+		mc = (MissingCellDummyRecord)r[cell00+9];
+		assertEquals(2, mc.getRow());
+		assertEquals(2, mc.getColumn());
+		
+		mc = (MissingCellDummyRecord)r[cell00+55];
+		assertEquals(22, mc.getRow());
+		assertEquals(10, mc.getColumn());
+	}
+
+	private static final class MockHSSFListener implements HSSFListener {
+		public MockHSSFListener() {}
+		private final List _records = new ArrayList();
+
+		public void processRecord(Record record) {
+			_records.add(record);
+			
+			if(record instanceof MissingRowDummyRecord) {
+				MissingRowDummyRecord mr = (MissingRowDummyRecord)record;
+				log("Got dummy row " + mr.getRowNumber());
+			}
+			if(record instanceof MissingCellDummyRecord) {
+				MissingCellDummyRecord mc = (MissingCellDummyRecord)record;
+				log("Got dummy cell " + mc.getRow() + " " + mc.getColumn());
+			}
+			if(record instanceof LastCellOfRowDummyRecord) {
+				LastCellOfRowDummyRecord lc = (LastCellOfRowDummyRecord)record;
+				log("Got end-of row, row was " + lc.getRow() + ", last column was " + lc.getLastColumnNumber());
+			}
+		}
+		private static void log(String msg) {
+			if(false) { // successful tests should be quiet
+				System.out.println(msg);
+			}
+		}
+		public Record[] getRecords() {
+			Record[] result = new Record[_records.size()];
+			_records.toArray(result);
+			return result;
+		}
+	}
+}