- reworked HexDump class - unified array dumps and usage of standard java calls for hex format

- fixed a few findbugs DM_DEFAULT_ENCODING issues
- removed a few System.out/.err calls - instead the poilogger is used
- closed a few left open resource instances

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

10 files changed, 215 insertions, 308 deletions

diff --git a/src/testcases/org/apache/poi/ddf/TestEscherDump.java b/src/testcases/org/apache/poi/ddf/TestEscherDump.java
index 276c15f414..718585592f 100644
--- a/src/testcases/org/apache/poi/ddf/TestEscherDump.java
+++ b/src/testcases/org/apache/poi/ddf/TestEscherDump.java
@@ -17,9 +17,12 @@
 
 package org.apache.poi.ddf;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertTrue;
 
 import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
 
 import org.apache.poi.POIDataSamples;
 import org.apache.poi.hssf.HSSFTestDataSamples;
@@ -30,23 +33,23 @@ public class TestEscherDump {
     @Test
     public void testSimple() throws Exception {
         // simple test to at least cover some parts of the class
-        EscherDump.main(new String[] {});
+        EscherDump.main(new String[] {}, new NullPrinterStream());
         
-        new EscherDump().dump(0, new byte[] {}, System.out);
-        new EscherDump().dump(new byte[] {}, 0, 0, System.out);
-        new EscherDump().dumpOld(0, new ByteArrayInputStream(new byte[] {}), System.out);
+        new EscherDump().dump(0, new byte[] {}, new NullPrinterStream());
+        new EscherDump().dump(new byte[] {}, 0, 0, new NullPrinterStream());
+        new EscherDump().dumpOld(0, new ByteArrayInputStream(new byte[] {}), new NullPrinterStream());
     }
 
     @Test
     public void testWithData() throws Exception {
-        new EscherDump().dumpOld(8, new ByteArrayInputStream(new byte[] { 00, 00, 00, 00, 00, 00, 00, 00 }), System.out);
+        new EscherDump().dumpOld(8, new ByteArrayInputStream(new byte[] { 00, 00, 00, 00, 00, 00, 00, 00 }), new NullPrinterStream());
     }
 
     @Test
     public  void testWithSamplefile() throws Exception {
         //InputStream stream = HSSFTestDataSamples.openSampleFileStream(")
         byte[] data = POIDataSamples.getDDFInstance().readFile("Container.dat");
-        new EscherDump().dump(data.length, data, System.out);
+        new EscherDump().dump(data.length, data, new NullPrinterStream());
         //new EscherDump().dumpOld(data.length, new ByteArrayInputStream(data), System.out);
         
         data = new byte[2586114];
@@ -55,4 +58,31 @@ public class TestEscherDump {
         //new EscherDump().dump(bytes, data, System.out);
         //new EscherDump().dumpOld(bytes, new ByteArrayInputStream(data), System.out);
     }
+    
+    /**
+     * Implementation of an OutputStream which does nothing, used
+     * to redirect stdout to avoid spamming the console with output
+     */
+    private static class NullPrinterStream extends PrintStream {
+        private NullPrinterStream() {
+            super(new NullOutputStream());
+        }
+        /**
+         * Implementation of an OutputStream which does nothing, used
+         * to redirect stdout to avoid spamming the console with output
+         */
+        private static class NullOutputStream extends OutputStream {
+            @Override
+            public void write(byte[] b, int off, int len) {
+            }
+
+            @Override
+            public void write(int b) {
+            }
+
+            @Override
+            public void write(byte[] b) throws IOException {
+            }
+        }        
+    }    
 }
diff --git a/src/testcases/org/apache/poi/hssf/dev/TestBiffViewer.java b/src/testcases/org/apache/poi/hssf/dev/TestBiffViewer.java
index a1d190ab58..776e278526 100644
--- a/src/testcases/org/apache/poi/hssf/dev/TestBiffViewer.java
+++ b/src/testcases/org/apache/poi/hssf/dev/TestBiffViewer.java
@@ -21,6 +21,11 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintStream;
 
+import org.apache.poi.POIDataSamples;
+import org.apache.poi.poifs.filesystem.NPOIFSFileSystem;
+import org.junit.Ignore;
+import org.junit.Test;
+
 public class TestBiffViewer extends BaseXLSIteratingTest {
 	static {
 		// these are likely ok to fail
@@ -43,21 +48,21 @@ public class TestBiffViewer extends BaseXLSIteratingTest {
 
 	@Override
 	void runOneFile(File file) throws IOException {
-		InputStream is = BiffViewer.getPOIFSInputStream(file);
+	    NPOIFSFileSystem fs  = new NPOIFSFileSystem(file, true);
+		InputStream is = BiffViewer.getPOIFSInputStream(fs);
 		try {
 			// use a NullOutputStream to not write the bytes anywhere for best runtime 
 			BiffViewer.runBiffViewer(new PrintStream(NULL_OUTPUT_STREAM), is, true, true, true, false);
 		} finally {
 			is.close();
+			fs.close();
 		}
 	}
 	
 //	@Test
+//	@Ignore("only used for manual tests")
 //	public void testOneFile() throws Exception {
-//		List<String> failed = new ArrayList<String>();
-//		runOneFile("test-data/spreadsheet", "WORKBOOK_in_capitals.xls", failed);
-//
-//		assertTrue("Expected to have no failed except the ones excluded, but had: " + failed, 
-//				failed.isEmpty());
+//	    POIDataSamples samples = POIDataSamples.getSpreadSheetInstance();
+//		runOneFile(samples.getFile("43493.xls"));
 //	}
 }
diff --git a/src/testcases/org/apache/poi/hssf/record/TestHyperlinkRecord.java b/src/testcases/org/apache/poi/hssf/record/TestHyperlinkRecord.java
index 8c7e71fb29..d1e5631b9d 100644
--- a/src/testcases/org/apache/poi/hssf/record/TestHyperlinkRecord.java
+++ b/src/testcases/org/apache/poi/hssf/record/TestHyperlinkRecord.java
@@ -17,14 +17,16 @@
 package org.apache.poi.hssf.record;
 
 import static org.junit.Assert.assertArrayEquals;
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.fail;
 
 import org.apache.poi.hssf.record.HyperlinkRecord.GUID;
 import org.apache.poi.util.HexDump;
 import org.apache.poi.util.HexRead;
 import org.apache.poi.util.LittleEndianByteArrayInputStream;
 import org.apache.poi.util.LittleEndianByteArrayOutputStream;
+import org.junit.Test;
 
 /**
  * Test HyperlinkRecord
@@ -32,7 +34,7 @@ import org.apache.poi.util.LittleEndianByteArrayOutputStream;
  * @author Nick Burch
  * @author Yegor Kozlov
  */
-public final class TestHyperlinkRecord extends TestCase {
+public final class TestHyperlinkRecord {
 
     //link to http://www.lakings.com/
     private static final byte[] data1 = { 0x02, 0x00,    //First row of the hyperlink
@@ -262,6 +264,8 @@ public final class TestHyperlinkRecord extends TestCase {
     private void confirmGUID(GUID expectedGuid, GUID actualGuid) {
 		assertEquals(expectedGuid, actualGuid);
 	}
+    
+    @Test
     public void testReadURLLink(){
         RecordInputStream is = TestcaseRecordInputStream.create(HyperlinkRecord.sid, data1);
         HyperlinkRecord link = new HyperlinkRecord(is);
@@ -281,6 +285,7 @@ public final class TestHyperlinkRecord extends TestCase {
         assertEquals("http://www.lakings.com/", link.getAddress());
     }
 
+    @Test
     public void testReadFileLink(){
         RecordInputStream is = TestcaseRecordInputStream.create(HyperlinkRecord.sid, data2);
         HyperlinkRecord link = new HyperlinkRecord(is);
@@ -300,6 +305,7 @@ public final class TestHyperlinkRecord extends TestCase {
         assertEquals("link1.xls", link.getAddress());
     }
 
+    @Test
     public void testReadEmailLink(){
         RecordInputStream is = TestcaseRecordInputStream.create(HyperlinkRecord.sid, data3);
         HyperlinkRecord link = new HyperlinkRecord(is);
@@ -318,6 +324,7 @@ public final class TestHyperlinkRecord extends TestCase {
         assertEquals("mailto:ebgans@mail.ru?subject=Hello,%20Ebgans!", link.getAddress());
     }
 
+    @Test
     public void testReadDocumentLink(){
         RecordInputStream is = TestcaseRecordInputStream.create(HyperlinkRecord.sid, data4);
         HyperlinkRecord link = new HyperlinkRecord(is);
@@ -347,6 +354,7 @@ public final class TestHyperlinkRecord extends TestCase {
         assertArrayEquals(bytes1, bytes2);
     }
 
+    @Test
     public void testSerialize(){
         serialize(data1);
         serialize(data2);
@@ -354,6 +362,7 @@ public final class TestHyperlinkRecord extends TestCase {
         serialize(data4);
     }
 
+    @Test
     public void testCreateURLRecord() {
         HyperlinkRecord link = new HyperlinkRecord();
         link.newUrlLink();
@@ -369,6 +378,7 @@ public final class TestHyperlinkRecord extends TestCase {
         assertArrayEquals(data1, ser);
     }
 
+    @Test
     public void testCreateFileRecord() {
         HyperlinkRecord link = new HyperlinkRecord();
         link.newFileLink();
@@ -384,6 +394,7 @@ public final class TestHyperlinkRecord extends TestCase {
         assertArrayEquals(data2, ser);
     }
 
+    @Test
     public void testCreateDocumentRecord() {
         HyperlinkRecord link = new HyperlinkRecord();
         link.newDocumentLink();
@@ -399,6 +410,7 @@ public final class TestHyperlinkRecord extends TestCase {
         assertArrayEquals(data4, ser);
     }
 
+    @Test
     public void testCreateEmailtRecord() {
         HyperlinkRecord link = new HyperlinkRecord();
         link.newUrlLink();
@@ -414,6 +426,7 @@ public final class TestHyperlinkRecord extends TestCase {
         assertArrayEquals(data3, ser);
     }
 
+    @Test
     public void testClone() {
         byte[][] data = {data1, data2, data3, data4};
         for (int i = 0; i < data.length; i++) {
@@ -425,27 +438,27 @@ public final class TestHyperlinkRecord extends TestCase {
 
     }
 
-	public void testReserializeTargetFrame() {
+    @Test
+    public void testReserializeTargetFrame() {
 		RecordInputStream in = TestcaseRecordInputStream.create(HyperlinkRecord.sid, dataTargetFrame);
 		HyperlinkRecord hr = new HyperlinkRecord(in);
 		byte[] ser = hr.serialize();
 		TestcaseRecordInputStream.confirmRecordEncoding(HyperlinkRecord.sid, dataTargetFrame, ser);
 	}
 
-
+    @Test
 	public void testReserializeLinkToWorkbook() {
 
 		RecordInputStream in = TestcaseRecordInputStream.create(HyperlinkRecord.sid, dataLinkToWorkbook);
 		HyperlinkRecord hr = new HyperlinkRecord(in);
 		byte[] ser = hr.serialize();
 		TestcaseRecordInputStream.confirmRecordEncoding(HyperlinkRecord.sid, dataLinkToWorkbook, ser);
-		if ("YEARFR~1.XLS".equals(hr.getAddress())) {
-			throw new AssertionFailedError("Identified bug in reading workbook link");
-		}
+		assertNotEquals("Identified bug in reading workbook link", "YEARFR~1.XLS", hr.getAddress());
 		assertEquals("yearfracExamples.xls", hr.getAddress());
 	}
 
-	public void testReserializeUNC() {
+    @Test
+    public void testReserializeUNC() {
 
 		RecordInputStream in = TestcaseRecordInputStream.create(HyperlinkRecord.sid, dataUNC);
 		HyperlinkRecord hr = new HyperlinkRecord(in);
@@ -454,10 +467,11 @@ public final class TestHyperlinkRecord extends TestCase {
 		try {
 			hr.toString();
 		} catch (NullPointerException e) {
-			throw new AssertionFailedError("Identified bug with option URL and UNC set at same time");
+		    fail("Identified bug with option URL and UNC set at same time");
 		}
 	}
 	
+    @Test
 	public void testGUID() {
 		GUID g;
 		g = GUID.parse("3F2504E0-4F89-11D3-9A0C-0305E82C3301");
@@ -489,12 +503,13 @@ public final class TestHyperlinkRecord extends TestCase {
 	}
 
 	private void confirmGUID(GUID g, int d1, int d2, int d3, long d4) {
-		assertEquals(new String(HexDump.intToHex(d1)), new String(HexDump.intToHex(g.getD1())));
-		assertEquals(new String(HexDump.shortToHex(d2)), new String(HexDump.shortToHex(g.getD2())));
-		assertEquals(new String(HexDump.shortToHex(d3)), new String(HexDump.shortToHex(g.getD3())));
-		assertEquals(new String(HexDump.longToHex(d4)), new String(HexDump.longToHex(g.getD4())));
+		assertEquals(HexDump.intToHex(d1), HexDump.intToHex(g.getD1()));
+		assertEquals(HexDump.shortToHex(d2), HexDump.shortToHex(g.getD2()));
+		assertEquals(HexDump.shortToHex(d3), HexDump.shortToHex(g.getD3()));
+		assertEquals(HexDump.longToHex(d4), HexDump.longToHex(g.getD4()));
 	}
 
+	@Test
     public void test47498(){
         RecordInputStream is = TestcaseRecordInputStream.create(HyperlinkRecord.sid, data_47498);
         HyperlinkRecord link = new HyperlinkRecord(is);
diff --git a/src/testcases/org/apache/poi/hssf/record/crypto/TestBiff8DecryptingStream.java b/src/testcases/org/apache/poi/hssf/record/crypto/TestBiff8DecryptingStream.java
index 6c8cd01779..26eb16b2f7 100644
--- a/src/testcases/org/apache/poi/hssf/record/crypto/TestBiff8DecryptingStream.java
+++ b/src/testcases/org/apache/poi/hssf/record/crypto/TestBiff8DecryptingStream.java
@@ -92,15 +92,15 @@ public final class TestBiff8DecryptingStream {
 		}
 
 		public void confirmByte(int expVal) {
-			cmp(HexDump.byteToHex(expVal), HexDump.byteToHex(_bds.readUByte()));
+		    assertEquals(HexDump.byteToHex(expVal), HexDump.byteToHex(_bds.readUByte()));
 		}
 
 		public void confirmShort(int expVal) {
-			cmp(HexDump.shortToHex(expVal), HexDump.shortToHex(_bds.readShort()));
+		    assertEquals(HexDump.shortToHex(expVal), HexDump.shortToHex(_bds.readShort()));
 		}
 
         public void confirmUShort(int expVal) {
-            cmp(HexDump.shortToHex(expVal), HexDump.shortToHex(_bds.readUShort()));
+            assertEquals(HexDump.shortToHex(expVal), HexDump.shortToHex(_bds.readUShort()));
         }
         
         public short readShort() {
@@ -112,25 +112,13 @@ public final class TestBiff8DecryptingStream {
         }
 
 		public void confirmInt(int expVal) {
-			cmp(HexDump.intToHex(expVal), HexDump.intToHex(_bds.readInt()));
+			assertEquals(HexDump.intToHex(expVal), HexDump.intToHex(_bds.readInt()));
 		}
 
 		public void confirmLong(long expVal) {
-			cmp(HexDump.longToHex(expVal), HexDump.longToHex(_bds.readLong()));
+		    assertEquals(HexDump.longToHex(expVal), HexDump.longToHex(_bds.readLong()));
 		}
 		
-		private void cmp(char[] exp, char[] act) {
-			if (Arrays.equals(exp, act)) {
-				return;
-			}
-			_errorsOccurred = true;
-			if (ONLY_LOG_ERRORS) {
-				logErr(3, "Value mismatch " + new String(exp) + " - " + new String(act));
-				return;
-			}
-			throw new ComparisonFailure("Value mismatch", new String(exp), new String(act));
-		}
-
 		public void confirmData(String expHexData) {
 
 			byte[] expData = HexRead.readFromString(expHexData);
diff --git a/src/testcases/org/apache/poi/poifs/storage/RawDataUtil.java b/src/testcases/org/apache/poi/poifs/storage/RawDataUtil.java
index d69fd681cf..dca549c888 100644
--- a/src/testcases/org/apache/poi/poifs/storage/RawDataUtil.java
+++ b/src/testcases/org/apache/poi/poifs/storage/RawDataUtil.java
@@ -50,9 +50,7 @@ public final class RawDataUtil {
 		System.out.println("String[] hexDataLines = {");
 		System.out.print("\t\"");
 		while(true) {
-			char[] cc = HexDump.byteToHex(data[i]);
-			System.out.print(cc[2]);
-			System.out.print(cc[3]);
+			System.out.print(HexDump.byteToHex(data[i]).substring(2));
 			i++;
 			if (i>=data.length) {
 				break;
diff --git a/src/testcases/org/apache/poi/ss/formula/eval/TestMinusZeroResult.java b/src/testcases/org/apache/poi/ss/formula/eval/TestMinusZeroResult.java
index 1ee9b45a8c..7500be57e4 100644
--- a/src/testcases/org/apache/poi/ss/formula/eval/TestMinusZeroResult.java
+++ b/src/testcases/org/apache/poi/ss/formula/eval/TestMinusZeroResult.java
@@ -142,7 +142,7 @@ public final class TestMinusZeroResult extends TestCase {
 		long bitsB = Double.doubleToLongBits(b);
 		if (bitsA != bitsB) {
 			throw new ComparisonFailure("value different to expected",
-					new String(HexDump.longToHex(bitsA)), new String(HexDump.longToHex(bitsB)));
+					HexDump.longToHex(bitsA), HexDump.longToHex(bitsB));
 		}
 	}
 }
diff --git a/src/testcases/org/apache/poi/ss/util/NumberComparingSpreadsheetGenerator.java b/src/testcases/org/apache/poi/ss/util/NumberComparingSpreadsheetGenerator.java
index d04bf402ec..d4f1ebb92f 100644
--- a/src/testcases/org/apache/poi/ss/util/NumberComparingSpreadsheetGenerator.java
+++ b/src/testcases/org/apache/poi/ss/util/NumberComparingSpreadsheetGenerator.java
@@ -125,9 +125,7 @@ public class NumberComparingSpreadsheetGenerator {
 
 	private static String formatDoubleAsHex(double d) {
 		long l = Double.doubleToLongBits(d);
-		StringBuilder sb = new StringBuilder(20);
-		sb.append(HexDump.longToHex(l)).append('L');
-		return sb.toString();
+		return HexDump.longToHex(l)+'L';
 	}
 
 	public static void main(String[] args) {
diff --git a/src/testcases/org/apache/poi/ss/util/TestExpandedDouble.java b/src/testcases/org/apache/poi/ss/util/TestExpandedDouble.java
index dd524fdb86..d4d63192d0 100644
--- a/src/testcases/org/apache/poi/ss/util/TestExpandedDouble.java
+++ b/src/testcases/org/apache/poi/ss/util/TestExpandedDouble.java
@@ -17,21 +17,24 @@
 
 package org.apache.poi.ss.util;
 
+import static org.junit.Assert.assertEquals;
+
 import java.math.BigDecimal;
 import java.math.BigInteger;
 
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
-
 import org.apache.poi.util.HexDump;
+import org.junit.Test;
+
+import junit.framework.AssertionFailedError;
 /**
  * Tests for {@link ExpandedDouble}
  *
  * @author Josh Micich
  */
-public final class TestExpandedDouble extends TestCase {
+public final class TestExpandedDouble {
 	private static final BigInteger BIG_POW_10 = BigInteger.valueOf(1000000000);
 
+	@Test
 	public void testNegative() {
 		ExpandedDouble hd = new ExpandedDouble(0xC010000000000000L);
 
@@ -44,6 +47,7 @@ public final class TestExpandedDouble extends TestCase {
 		assertEquals(1, frac.bitCount());
 	}
 
+	@Test
 	public void testSubnormal() {
 		ExpandedDouble hd = new ExpandedDouble(0x0000000000000001L);
 
@@ -59,6 +63,7 @@ public final class TestExpandedDouble extends TestCase {
 	/**
 	 * Tests specific values for conversion from {@link ExpandedDouble} to {@link NormalisedDecimal} and back
 	 */
+	@Test
 	public void testRoundTripShifting() {
 		long[] rawValues = {
 				0x4010000000000004L,
@@ -87,6 +92,7 @@ public final class TestExpandedDouble extends TestCase {
 			throw new AssertionFailedError("One or more test examples failed.  See stderr.");
 		}
 	}
+	
 	public static boolean confirmRoundTrip(int i, long rawBitsA) {
 		double a = Double.longBitsToDouble(rawBitsA);
 		if (a == 0.0) {
@@ -150,6 +156,7 @@ public final class TestExpandedDouble extends TestCase {
 		}
 		return bd.unscaledValue().toString();
 	}
+	
 	public static BigInteger getNearby(NormalisedDecimal md, int offset) {
 		BigInteger frac = md.composeFrac();
 		int be = frac.bitLength() - 24 - 1;
@@ -218,8 +225,6 @@ public final class TestExpandedDouble extends TestCase {
 
 	private static String formatDoubleAsHex(double d) {
 		long l = Double.doubleToLongBits(d);
-		StringBuilder sb = new StringBuilder(20);
-		sb.append(HexDump.longToHex(l)).append('L');
-		return sb.toString();
+		return HexDump.longToHex(l)+'L';
 	}
 }
diff --git a/src/testcases/org/apache/poi/ss/util/TestNumberComparer.java b/src/testcases/org/apache/poi/ss/util/TestNumberComparer.java
index 7c3d87e99a..506df67494 100644
--- a/src/testcases/org/apache/poi/ss/util/TestNumberComparer.java
+++ b/src/testcases/org/apache/poi/ss/util/TestNumberComparer.java
@@ -17,18 +17,21 @@
 
 package org.apache.poi.ss.util;
 
-import junit.framework.AssertionFailedError;
-import junit.framework.TestCase;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 import org.apache.poi.ss.util.NumberComparisonExamples.ComparisonExample;
 import org.apache.poi.util.HexDump;
+import org.junit.Test;
 /**
  * Tests for {@link NumberComparer}
  *
  * @author Josh Micich
  */
-public final class TestNumberComparer extends TestCase {
+public final class TestNumberComparer {
 
+    @Test
 	public void testAllComparisonExamples() {
 		ComparisonExample[] examples = NumberComparisonExamples.getComparisonExamples();
 		boolean success = true;
@@ -40,11 +43,11 @@ public final class TestNumberComparer extends TestCase {
 			success &= confirm(i, ce.getNegA(), ce.getNegB(), -ce.getExpectedResult());
 			success &= confirm(i, ce.getNegB(), ce.getNegA(), +ce.getExpectedResult());
 		}
-		if (!success) {
-			throw new AssertionFailedError("One or more cases failed.  See stderr");
-		}
+		
+		assertTrue("One or more cases failed.  See stderr", success);
 	}
 
+    @Test
 	public void testRoundTripOnComparisonExamples() {
 		ComparisonExample[] examples = NumberComparisonExamples.getComparisonExamples();
 		boolean success = true;
@@ -55,10 +58,8 @@ public final class TestNumberComparer extends TestCase {
 			success &= confirmRoundTrip(i, ce.getB());
 			success &= confirmRoundTrip(i, ce.getNegB());
 		}
-		if (!success) {
-			throw new AssertionFailedError("One or more cases failed.  See stderr");
-		}
-
+		
+		assertTrue("One or more cases failed.  See stderr", success);
 	}
 
 	private boolean confirmRoundTrip(int i, double a) {
@@ -68,6 +69,7 @@ public final class TestNumberComparer extends TestCase {
 	/**
 	 * The actual example from bug 47598
 	 */
+	@Test
 	public void testSpecificExampleA() {
 		double a = 0.06-0.01;
 		double b = 0.05;
@@ -78,6 +80,7 @@ public final class TestNumberComparer extends TestCase {
 	/**
 	 * The example from the nabble posting
 	 */
+	@Test
 	public void testSpecificExampleB() {
 		double a = 1+1.0028-0.9973;
 		double b = 1.0055;
@@ -99,8 +102,6 @@ public final class TestNumberComparer extends TestCase {
 	}
 	private static String formatDoubleAsHex(double d) {
 		long l = Double.doubleToLongBits(d);
-		StringBuilder sb = new StringBuilder(20);
-		sb.append(HexDump.longToHex(l)).append('L');
-		return sb.toString();
+		return HexDump.longToHex(l)+'L';
 	}
 }
diff --git a/src/testcases/org/apache/poi/util/TestHexDump.java b/src/testcases/org/apache/poi/util/TestHexDump.java
index 883cedd91e..11cd4cb9a7 100644
--- a/src/testcases/org/apache/poi/util/TestHexDump.java
+++ b/src/testcases/org/apache/poi/util/TestHexDump.java
@@ -17,6 +17,12 @@
 
 package org.apache.poi.util;
 
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -26,243 +32,116 @@ import java.io.InputStream;
 import java.io.PrintStream;
 import java.lang.reflect.Constructor;
 
-import junit.framework.TestCase;
-
-/**
- * @author Glen Stampoultzis (glens at apache.org)
- * @author Marc Johnson (mjohnson at apache dot org)
- */
-public final class TestHexDump extends TestCase {
-
-
-    private static char toHex(int n) {
-        return Character.toUpperCase(Character.forDigit(n & 0x0F, 16));
-    }
+import org.junit.Test;
 
+public final class TestHexDump {
+    @Test
     public void testDump() throws IOException {
         byte[] testArray = new byte[ 256 ];
 
-        for (int j = 0; j < 256; j++)
-        {
+        for (int j = 0; j < 256; j++) {
             testArray[ j ] = ( byte ) j;
         }
-        ByteArrayOutputStream stream = new ByteArrayOutputStream();
+        ByteArrayOutputStream streamAct = new ByteArrayOutputStream();
+        HexDump.dump(testArray, 0, streamAct, 0);
+        byte bytesAct[] = streamAct.toByteArray();
+        byte bytesExp[] = toHexDump(0,0);
 
-        HexDump.dump(testArray, 0, stream, 0);
-        byte[] outputArray = new byte[ 16 * (73 + HexDump.EOL.length()) ];
-
-        for (int j = 0; j < 16; j++)
-        {
-            int offset = (73 + HexDump.EOL.length()) * j;
-
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) toHex(j);
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) ' ';
-            for (int k = 0; k < 16; k++)
-            {
-                outputArray[ offset++ ] = ( byte ) toHex(j);
-                outputArray[ offset++ ] = ( byte ) toHex(k);
-                outputArray[ offset++ ] = ( byte ) ' ';
-            }
-            for (int k = 0; k < 16; k++)
-            {
-                outputArray[ offset++ ] = ( byte ) toAscii((j * 16) + k);
-            }
-            System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset,
-                             HexDump.EOL.getBytes().length);
-        }
-        byte[] actualOutput = stream.toByteArray();
-
-        assertEquals("array size mismatch", outputArray.length,
-                     actualOutput.length);
-        for (int j = 0; j < outputArray.length; j++)
-        {
-            assertEquals("array[ " + j + "] mismatch", outputArray[ j ],
-                         actualOutput[ j ]);
-        }
+        assertEquals("array size mismatch", bytesExp.length, bytesAct.length);
+        assertArrayEquals("array mismatch", bytesExp, bytesAct);
 
         // verify proper behavior with non-zero offset
-        stream = new ByteArrayOutputStream();
-        HexDump.dump(testArray, 0x10000000, stream, 0);
-        outputArray = new byte[ 16 * (73 + HexDump.EOL.length()) ];
-        for (int j = 0; j < 16; j++)
-        {
-            int offset = (73 + HexDump.EOL.length()) * j;
-
-            outputArray[ offset++ ] = ( byte ) '1';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) toHex(j);
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) ' ';
-            for (int k = 0; k < 16; k++)
-            {
-                outputArray[ offset++ ] = ( byte ) toHex(j);
-                outputArray[ offset++ ] = ( byte ) toHex(k);
-                outputArray[ offset++ ] = ( byte ) ' ';
-            }
-            for (int k = 0; k < 16; k++)
-            {
-                outputArray[ offset++ ] = ( byte ) toAscii((j * 16) + k);
-            }
-            System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset,
-                             HexDump.EOL.getBytes().length);
-        }
-        actualOutput = stream.toByteArray();
-        assertEquals("array size mismatch", outputArray.length,
-                     actualOutput.length);
-        for (int j = 0; j < outputArray.length; j++)
-        {
-            assertEquals("array[ " + j + "] mismatch", outputArray[ j ],
-                         actualOutput[ j ]);
-        }
+        streamAct.reset();
+        HexDump.dump(testArray, 0x10000000L, streamAct, 0);
+        bytesAct = streamAct.toByteArray();
+        bytesExp = toHexDump(0x10000000L,0);
+        
+        assertEquals("array size mismatch", bytesExp.length, bytesAct.length);
+        assertArrayEquals("array mismatch", bytesExp, bytesAct);
 
         // verify proper behavior with negative offset
-        stream = new ByteArrayOutputStream();
-        HexDump.dump(testArray, 0xFF000000, stream, 0);
-        outputArray = new byte[ 16 * (73 + HexDump.EOL.length()) ];
-        for (int j = 0; j < 16; j++)
-        {
-            int offset = (73 + HexDump.EOL.length()) * j;
-
-            outputArray[ offset++ ] = ( byte ) 'F';
-            outputArray[ offset++ ] = ( byte ) 'F';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) toHex(j);
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) ' ';
-            for (int k = 0; k < 16; k++)
-            {
-                outputArray[ offset++ ] = ( byte ) toHex(j);
-                outputArray[ offset++ ] = ( byte ) toHex(k);
-                outputArray[ offset++ ] = ( byte ) ' ';
-            }
-            for (int k = 0; k < 16; k++)
-            {
-                outputArray[ offset++ ] = ( byte ) toAscii((j * 16) + k);
-            }
-            System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset,
-                             HexDump.EOL.getBytes().length);
-        }
-        actualOutput = stream.toByteArray();
-        assertEquals("array size mismatch", outputArray.length,
-                     actualOutput.length);
-        for (int j = 0; j < outputArray.length; j++)
-        {
-            assertEquals("array[ " + j + "] mismatch", outputArray[ j ],
-                         actualOutput[ j ]);
-        }
+        streamAct.reset();
+        HexDump.dump(testArray, 0xFF000000L, streamAct, 0);
+        bytesAct = streamAct.toByteArray();
+        bytesExp = toHexDump(0xFF000000L,0);
+
+        assertEquals("array size mismatch", bytesExp.length, bytesAct.length);
+        assertArrayEquals("array mismatch", bytesExp, bytesAct);
 
         // verify proper behavior with non-zero index
-        stream = new ByteArrayOutputStream();
-        HexDump.dump(testArray, 0x10000000, stream, 0x81);
-        outputArray = new byte[ (8 * (73 + HexDump.EOL.length())) - 1 ];
-        for (int j = 0; j < 8; j++)
-        {
-            int offset = (73 + HexDump.EOL.length()) * j;
-
-            outputArray[ offset++ ] = ( byte ) '1';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) '0';
-            outputArray[ offset++ ] = ( byte ) toHex(j + 8);
-            outputArray[ offset++ ] = ( byte ) '1';
-            outputArray[ offset++ ] = ( byte ) ' ';
-            for (int k = 0; k < 16; k++)
-            {
-                int index = 0x81 + (j * 16) + k;
-
-                if (index < 0x100)
-                {
-                    outputArray[ offset++ ] = ( byte ) toHex(index / 16);
-                    outputArray[ offset++ ] = ( byte ) toHex(index);
-                }
-                else
-                {
-                    outputArray[ offset++ ] = ( byte ) ' ';
-                    outputArray[ offset++ ] = ( byte ) ' ';
-                }
-                outputArray[ offset++ ] = ( byte ) ' ';
-            }
-            for (int k = 0; k < 16; k++)
-            {
-                int index = 0x81 + (j * 16) + k;
+        streamAct.reset();
+        HexDump.dump(testArray, 0xFF000000L, streamAct, 0x81);
+        bytesAct = streamAct.toByteArray();
+        bytesExp = toHexDump(0xFF000000L,0x81);
+
+        assertEquals("array size mismatch", bytesExp.length, bytesAct.length);
+        assertArrayEquals("array mismatch", bytesExp, bytesAct);
 
-                if (index < 0x100)
-                {
-                    outputArray[ offset++ ] = ( byte ) toAscii(index);
-                }
-            }
-            System.arraycopy(HexDump.EOL.getBytes(), 0, outputArray, offset,
-                             HexDump.EOL.getBytes().length);
-        }
-        actualOutput = stream.toByteArray();
-        assertEquals("array size mismatch", outputArray.length,
-                     actualOutput.length);
-        for (int j = 0; j < outputArray.length; j++)
-        {
-            assertEquals("array[ " + j + "] mismatch", outputArray[ j ],
-                         actualOutput[ j ]);
-        }
 
         // verify proper behavior with negative index
-        try
-        {
-            HexDump.dump(testArray, 0x10000000, new ByteArrayOutputStream(), -1);
+        try {
+            streamAct.reset();
+            HexDump.dump(testArray, 0x10000000L, streamAct, -1);
             fail("should have caught ArrayIndexOutOfBoundsException on negative index");
-        }
-        catch (ArrayIndexOutOfBoundsException ignored_exception)
-        {
-
+        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
             // as expected
         }
 
         // verify proper behavior with index that is too large
-        try
-        {
-            HexDump.dump(testArray, 0x10000000, new ByteArrayOutputStream(),
-                         testArray.length);
+        try {
+            streamAct.reset();
+            HexDump.dump(testArray, 0x10000000L, streamAct, testArray.length);
             fail("should have caught ArrayIndexOutOfBoundsException on large index");
-        }
-        catch (ArrayIndexOutOfBoundsException ignored_exception)
-        {
-
+        } catch (ArrayIndexOutOfBoundsException ignored_exception) {
             // as expected
         }
 
         // verify proper behavior with null stream
-        try
-        {
-            HexDump.dump(testArray, 0x10000000, null, 0);
+        try {
+            HexDump.dump(testArray, 0x10000000L, null, 0);
             fail("should have caught IllegalArgumentException on negative index");
-        }
-        catch (IllegalArgumentException ignored_exception)
-        {
+        } catch (IllegalArgumentException ignored_exception) {
 
             // as expected
         }
 
         // verify proper behaviour with empty byte array
-        ByteArrayOutputStream os = new ByteArrayOutputStream( );
-        HexDump.dump( new byte[0], 0, os, 0 );
-        assertEquals( "No Data" + System.getProperty( "line.separator"), os.toString() );
+        streamAct.reset();
+        HexDump.dump( new byte[0], 0, streamAct, 0 );
+        assertEquals( "No Data" + System.getProperty( "line.separator"), streamAct.toString() );
 
     }
+    
+    private byte[] toHexDump(long offset, int index) {
+        StringBuilder strExp = new StringBuilder(), chrs = new StringBuilder();
+        Object obj[] = new Object[33];
+        StringBuilder format = new StringBuilder();
+        
+        for (int j = 0; j < 16 && (index + j*16) < 256; j++) {
+            obj[0] = offset+index+j*16;
+            chrs.setLength(0);
+            format.setLength(0);
+            format.append("%08X ");
+            for (int k = 0; k < 16; k++) {
+                if (index+j*16+k < 256){
+                    obj[k+1] = index+j*16+k;
+                    chrs.append(HexDump.toAscii(index+j*16+k));
+                    format.append("%02X ");
+                } else {
+                    format.append("   ");
+                }
+            }
+            obj[17] = chrs.toString();
+            format.append("%18$s"+HexDump.EOL);
+            
+            String str = String.format(format.toString(), obj);
+            strExp.append(str);
+        }
+        byte bytesExp[] = strExp.toString().getBytes(HexDump.UTF8);
+        return bytesExp;
+    }
 
+    @Test
     public void testToHex() {
         assertEquals("000A", HexDump.toHex((short)0xA));
         
@@ -287,29 +166,17 @@ public final class TestHexDump extends TestCase {
         
         assertEquals("00000000000004D2", HexDump.toHex(1234l));
         
-        confirmStr("0xFE", HexDump.byteToHex(-2));
-        confirmStr("0x25", HexDump.byteToHex(37));
-        confirmStr("0xFFFE", HexDump.shortToHex(-2));
-        confirmStr("0x0005", HexDump.shortToHex(5));
-        confirmStr("0xFFFFFF9C", HexDump.intToHex(-100));
-        confirmStr("0x00001001", HexDump.intToHex(4097));
-        confirmStr("0xFFFFFFFFFFFF0006", HexDump.longToHex(-65530));
-        confirmStr("0x0000000000003FCD", HexDump.longToHex(16333));
+        assertEquals("0xFE", HexDump.byteToHex(-2));
+        assertEquals("0x25", HexDump.byteToHex(37));
+        assertEquals("0xFFFE", HexDump.shortToHex(-2));
+        assertEquals("0x0005", HexDump.shortToHex(5));
+        assertEquals("0xFFFFFF9C", HexDump.intToHex(-100));
+        assertEquals("0x00001001", HexDump.intToHex(4097));
+        assertEquals("0xFFFFFFFFFFFF0006", HexDump.longToHex(-65530));
+        assertEquals("0x0000000000003FCD", HexDump.longToHex(16333));
     }
 
-    private static void confirmStr(String expected, char[] actualChars) {
-        assertEquals(expected, new String(actualChars));
-    }
-
-    private static char toAscii(int c) {
-        char rval = '.';
-
-        if (c >= 32 && c <= 126) {
-            rval = ( char ) c;
-        }
-        return rval;
-    }
-    
+	@Test
     public void testDumpToString() throws Exception {
         byte[] testArray = new byte[ 256 ];
 
@@ -328,24 +195,22 @@ public final class TestHexDump extends TestCase {
                 dump.contains("123456789:;<=>?@"));
     }
 
-    public void testDumpToStringOutOfIndex() throws Exception {
-        byte[] testArray = new byte[ 0 ];
+    @Test(expected=ArrayIndexOutOfBoundsException.class)
+    public void testDumpToStringOutOfIndex1() throws Exception {
+        HexDump.dump(new byte[ 1 ], 0, -1);
+    }
 
-        try {
-            HexDump.dump(testArray, 0, -1);
-            fail("Should throw an exception with invalid input");
-        } catch (ArrayIndexOutOfBoundsException e) {
-            // expected
-        }
+    @Test(expected=ArrayIndexOutOfBoundsException.class)
+    public void testDumpToStringOutOfIndex2() throws Exception {
+        HexDump.dump(new byte[ 1 ], 0, 2);
+    }
 
-        try {
-            HexDump.dump(testArray, 0, 1);
-            fail("Should throw an exception with invalid input");
-        } catch (ArrayIndexOutOfBoundsException e) {
-            // expected
-        }
+    public void testDumpToStringOutOfIndex3() throws Exception {
+        HexDump.dump(new byte[ 1 ], 0, 1);
     }
     
+    
+    @Test
     public void testDumpToPrintStream() throws IOException {
         byte[] testArray = new byte[ 256 ];
 
@@ -425,6 +290,7 @@ public final class TestHexDump extends TestCase {
         }
     }
     
+    @Test
     public void testConstruct() throws Exception {
         // to cover private constructor
         // get the default constructor
@@ -437,6 +303,7 @@ public final class TestHexDump extends TestCase {
         assertNotNull(c.newInstance((Object[]) null));        
     }
     
+    @Test
     public void testMain() throws Exception {
         File file = TempFile.createTempFile("HexDump", ".dat");
         try {