moparisthebest/poi
1
0
Fork 0
Code Issues Pull Requests Releases 1 Wiki Activity

Test cases for HPSF writing capability added.

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/jakarta/poi/trunk@353320 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Rainer Klute 2003-08-30 09:11:59 +00:00
parent 79f4e5f844
commit aeaa6a0856
4 changed files with 545 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
src/testcases/org/apache/poi/hpsf/basic/POIFile.java
View File

@ -72,31 +72,62 @@ public class POIFile
private POIFSDocumentPath path;
private byte[] bytes;
/**
* <p>Sets the POI file's name.</p>
*
* @param name The POI file's name.
*/
public void setName(final String name)
{
this.name = name;
}
/**
* <p>Returns the POI file's name.</p>
*
* @return The POI file's name.
*/
public String getName()
{
return name;
}
/**
* <p>Sets the POI file's path.</p>
*
* @param path The POI file's path.
*/
public void setPath(final POIFSDocumentPath path)
{
this.path = path;
}
/**
* <p>Returns the POI file's path.</p>
*
* @return The POI file's path.
*/
public POIFSDocumentPath getPath()
{
return path;
}
/**
* <p>Sets the POI file's content bytes.</p>
*
* @param bytes The POI file's content bytes.
*/
public void setBytes(final byte[] bytes)
{
this.bytes = bytes;
}
/**
* <p>Returns the POI file's content bytes.</p>
*
* @return The POI file's content bytes.
*/
public byte[] getBytes()
{
return bytes;

25
src/testcases/org/apache/poi/hpsf/basic/TestBasic.java
View File

@ -55,16 +55,11 @@
package org.apache.poi.hpsf.basic;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import junit.framework.Assert;
import junit.framework.TestCase;
@ -77,8 +72,6 @@ import org.apache.poi.hpsf.PropertySet;
import org.apache.poi.hpsf.PropertySetFactory;
import org.apache.poi.hpsf.SummaryInformation;
import org.apache.poi.hpsf.UnexpectedPropertySetTypeException;
import org.apache.poi.poifs.filesystem.DocumentEntry;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
@ -122,6 +115,11 @@ public class TestBasic extends TestCase
/**
* <p>Test case constructor.</p>
*
* @param name The test case's name.
*/
public TestBasic(final String name)
{
super(name);
@ -131,6 +129,9 @@ public class TestBasic extends TestCase
/**
* <p>Read a the test file from the "data" directory.</p>
*
* @exception FileNotFoundException if the file to be read does not exist.
* @exception IOException if any other I/O exception occurs.
*/
public void setUp() throws FileNotFoundException, IOException
{
@ -146,6 +147,8 @@ public class TestBasic extends TestCase
/**
* <p>Checks the names of the files in the POI filesystem. They
* are expected to be in a certain order.</p>
*
* @exception IOException if an I/O exception occurs
*/
public void testReadFiles() throws IOException
{
@ -164,6 +167,8 @@ public class TestBasic extends TestCase
* property sets. In the latter cases a {@link
* NoPropertySetStreamException} will be thrown when trying to
* create a {@link PropertySet}.</p>
*
* @exception IOException if an I/O exception occurs
*/
public void testCreatePropertySets() throws IOException
{
@ -206,6 +211,9 @@ public class TestBasic extends TestCase
* <p>Tests the {@link PropertySet} methods. The test file has two
* property sets: the first one is a {@link SummaryInformation},
* the second one is a {@link DocumentSummaryInformation}.</p>
*
* @exception IOException if an I/O exception occurs
* @exception HPSFException if any HPSF exception occurs
*/
public void testPropertySetMethods() throws IOException, HPSFException
{
@ -251,7 +259,6 @@ public class TestBasic extends TestCase
for (int i = 0; i < fileList.length; i++)
{
File f = fileList[i];
System.out.println("Reading file " + f);
/* Read the POI filesystem's property set streams: */
final POIFile[] psf1 = Util.readPropertySets(f);
@ -266,7 +273,7 @@ public class TestBasic extends TestCase
catch (Throwable t)
{
final String s = Util.toString(t);
System.err.println(s);
fail(s);
}
}

8
src/testcases/org/apache/poi/hpsf/basic/TestUnicode.java
View File

@ -104,6 +104,9 @@ public class TestUnicode extends TestCase
/**
* <p>Read a the test file from the "data" directory.</p>
*
* @exception FileNotFoundException if the file to be read does not exist.
* @exception IOException if any other I/O exception occurs
*/
protected void setUp() throws FileNotFoundException, IOException
{
@ -118,6 +121,9 @@ public class TestUnicode extends TestCase
* <p>Tests the {@link PropertySet} methods. The test file has two
* property set: the first one is a {@link SummaryInformation},
* the second one is a {@link DocumentSummaryInformation}.</p>
*
* @exception IOException if an I/O exception occurs
* @exception HPSFException if an HPSF exception occurs
*/
public void testPropertySetMethods() throws IOException, HPSFException
{
@ -144,6 +150,8 @@ public class TestUnicode extends TestCase
/**
* <p>Runs the test cases stand-alone.</p>
*
* @param args Command-line arguments.
*/
public static void main(final String[] args)
{

490
src/testcases/org/apache/poi/hpsf/basic/TestWrite.java Normal file
View File

@ -0,0 +1,490 @@
/* ====================================================================
* 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.hpsf.basic;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.Date;
import java.util.Iterator;
import junit.framework.TestCase;
import org.apache.poi.hpsf.HPSFRuntimeException;
import org.apache.poi.hpsf.MutableProperty;
import org.apache.poi.hpsf.MutablePropertySet;
import org.apache.poi.hpsf.MutableSection;
import org.apache.poi.hpsf.Property;
import org.apache.poi.hpsf.PropertySet;
import org.apache.poi.hpsf.PropertySetFactory;
import org.apache.poi.hpsf.Section;
import org.apache.poi.hpsf.SummaryInformation;
import org.apache.poi.hpsf.UnsupportedVariantTypeException;
import org.apache.poi.hpsf.Variant;
import org.apache.poi.hpsf.VariantSupport;
import org.apache.poi.hpsf.wellknown.SectionIDMap;
import org.apache.poi.poifs.eventfilesystem.POIFSReader;
import org.apache.poi.poifs.eventfilesystem.POIFSReaderEvent;
import org.apache.poi.poifs.eventfilesystem.POIFSReaderListener;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.util.LittleEndian;
/**
* <p>Tests HPSF's writing functionality.</p>
*
* @author Rainer Klute (klute@rainer-klute.de)
* @since 2003-02-07
* @version $Id$
*/
public class TestWrite extends TestCase
{
static final String POI_FS = "TestHPSFWritingFunctionality.doc";
static final int BYTE_ORDER = 0xfffe;
static final int FORMAT = 0x0000;
static final int OS_VERSION = 0x00020A04;
static final int[] SECTION_COUNT = {1, 2};
static final boolean[] IS_SUMMARY_INFORMATION = {true, false};
static final boolean[] IS_DOCUMENT_SUMMARY_INFORMATION = {false, true};
POIFile[] poiFiles;
/**
* <p>Constructor</p>
*
* @param name the test case's name
*/
public TestWrite(final String name)
{
super(name);
}
/**
* @see TestCase#setUp()
*/
public void setUp()
{
VariantSupport.setLogUnsupportedTypes(false);
}
/**
* <p>Writes an empty property set to a POIFS and reads it back
* in.</p>
*
* @exception IOException if an I/O exception occurs
* @exception UnsupportedVariantTypeException if HPSF does not yet support
* a variant type to be written
*/
public void testWriteEmptyPropertySet()
throws IOException, UnsupportedVariantTypeException
{
final File dataDir =
new File(System.getProperty("HPSF.testdata.path"));
final File filename = new File(dataDir, POI_FS);
filename.deleteOnExit();
/* Create a mutable property set and write it to a POIFS: */
final OutputStream out = new FileOutputStream(filename);
final POIFSFileSystem poiFs = new POIFSFileSystem();
final MutablePropertySet ps = new MutablePropertySet();
final MutableSection s = (MutableSection) ps.getSections().get(0);
s.setFormatID(SectionIDMap.SUMMARY_INFORMATION_ID);
final ByteArrayOutputStream psStream = new ByteArrayOutputStream();
ps.write(psStream);
psStream.close();
final byte[] streamData = psStream.toByteArray();
poiFs.createDocument(new ByteArrayInputStream(streamData),
SummaryInformation.DEFAULT_STREAM_NAME);
poiFs.writeFilesystem(out);
out.close();
/* Read the POIFS: */
final POIFSReader r = new POIFSReader();
r.registerListener(new MyPOIFSReaderListener(),
SummaryInformation.DEFAULT_STREAM_NAME);
r.read(new FileInputStream(filename));
}
static class MyPOIFSReaderListener implements POIFSReaderListener
{
public void processPOIFSReaderEvent(final POIFSReaderEvent event)
{
try
{
PropertySetFactory.create(event.getStream());
}
catch (Exception ex)
{
ex.printStackTrace();
throw new RuntimeException(ex);
}
}
}
/**
* <p>Writes and reads back various variant types and checks whether the
* stuff that has been read back equals the stuff that was written.</p>
*/
public void testVariantTypes()
{
Throwable t = null;
try
{
check(Variant.VT_EMPTY, null);
check(Variant.VT_BOOL, new Boolean(true));
check(Variant.VT_BOOL, new Boolean(false));
check(Variant.VT_CF, new byte[]{0});
check(Variant.VT_CF, new byte[]{0, 1});
check(Variant.VT_CF, new byte[]{0, 1, 2});
check(Variant.VT_CF, new byte[]{0, 1, 2, 3});
check(Variant.VT_CF, new byte[]{0, 1, 2, 3, 4});
check(Variant.VT_CF, new byte[]{0, 1, 2, 3, 4, 5});
check(Variant.VT_CF, new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
check(Variant.VT_I2, new Integer(27));
check(Variant.VT_I4, new Long(28));
check(Variant.VT_FILETIME, new Date());
check(Variant.VT_LPSTR, "");
check(Variant.VT_LPSTR, "ä");
check(Variant.VT_LPSTR, "äö");
check(Variant.VT_LPSTR, "äöü");
check(Variant.VT_LPSTR, "äöüÄ");
check(Variant.VT_LPSTR, "äöüÄÖ");
check(Variant.VT_LPSTR, "äöüÄÖÜ");
check(Variant.VT_LPSTR, "äöüÄÖÜß");
check(Variant.VT_LPWSTR, "");
check(Variant.VT_LPWSTR, "ä");
check(Variant.VT_LPWSTR, "äö");
check(Variant.VT_LPWSTR, "äöü");
check(Variant.VT_LPWSTR, "äöüÄ");
check(Variant.VT_LPWSTR, "äöüÄÖ");
check(Variant.VT_LPWSTR, "äöüÄÖÜ");
check(Variant.VT_LPWSTR, "äöüÄÖÜß");
}
catch (Exception ex)
{
t = ex;
}
catch (Error ex)
{
t = ex;
}
if (t != null)
{
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
t.printStackTrace(pw);
pw.close();
try
{
sw.close();
}
catch (IOException ex2)
{
t.printStackTrace();
}
fail(sw.toString());
}
}
/**
* <p>Writes a property and reads it back in.</p>
*
* @param variantType The property's variant type.
* @param value The property's value.
* @throws UnsupportedVariantTypeException if the variant is not supported.
* @throws IOException if an I/O exception occurs.
*/
private void check(final long variantType, final Object value)
throws UnsupportedVariantTypeException, IOException
{
final ByteArrayOutputStream out = new ByteArrayOutputStream();
VariantSupport.write(out, variantType, value);
out.close();
final byte[] b = out.toByteArray();
final Object objRead =
VariantSupport.read(b, 0, b.length + LittleEndian.INT_SIZE,
variantType);
if (objRead instanceof byte[])
{
final int diff = diff(org.apache.poi.hpsf.Util.pad4
((byte[]) value), (byte[]) objRead);
if (diff >= 0)
fail("Byte arrays are different. First different byte is at " +
"index " + diff + ".");
}
else
assertEquals(value, objRead);
}
/**
* <p>Compares two byte arrays.</p>
*
* @param a The first byte array
* @param b The second byte array
* @return The index of the first byte that is different. If the byte arrays
* are equal, -1 is returned.
*/
private int diff(final byte[] a, final byte[] b)
{
final int min = Math.min(a.length, b.length);
for (int i = 0; i < min; i++)
if (a[i] != b[i])
return i;
if (a.length != b.length)
return min;
return -1;
}
/**
* <p>This test method does a write and read back test with all POI
* filesystems in the "data" directory by performing the following
* actions for each file:</p>
*
* <ul>
*
* <li><p>Read its property set streams.</p></li>
*
* <li><p>Create a new POI filesystem containing the origin file's
* property set streams.</p></li>
*
* <li><p>Read the property set streams from the POI filesystem just
* created.</p></li>
*
* <li><p>Compare each property set stream with the corresponding one from
* the origin file and check whether they are equal.</p></li>
*
* </ul>
*/
public void testRecreate()
{
final File dataDir =
new File(System.getProperty("HPSF.testdata.path"));
final File[] fileList = dataDir.listFiles(new FileFilter()
{
public boolean accept(final File f)
{
return f.isFile();
}
});
for (int i = 0; i < fileList.length; i++)
testRecreate(fileList[i]);
}
/**
* <p>Performs the check described in {@link #testRecreate()} for a single
* POI filesystem.</p>
*
* @param f the POI filesystem to check
*/
private void testRecreate(final File f)
{
try
{
/* Read the POI filesystem's property set streams: */
final POIFile[] psf1 = Util.readPropertySets(f);
/* Create a new POI filesystem containing the origin file's
* property set streams: */
final File copy = File.createTempFile(f.getName(), "");
copy.deleteOnExit();
final OutputStream out = new FileOutputStream(copy);
final POIFSFileSystem poiFs = new POIFSFileSystem();
for (int i = 0; i < psf1.length; i++)
{
final InputStream in =
new ByteArrayInputStream(psf1[i].getBytes());
final PropertySet psIn = PropertySetFactory.create(in);
final MutablePropertySet psOut = copy(psIn);
final ByteArrayOutputStream psStream =
new ByteArrayOutputStream();
psOut.write(psStream);
psStream.close();
final byte[] streamData = psStream.toByteArray();
poiFs.createDocument(new ByteArrayInputStream(streamData),
psf1[i].getName());
poiFs.writeFilesystem(out);
}
out.close();
/* Read the property set streams from the POI filesystem just
* created. */
final POIFile[] psf2 = Util.readPropertySets(copy);
for (int i = 0; i < psf2.length; i++)
{
final byte[] bytes1 = psf1[i].getBytes();
final byte[] bytes2 = psf2[i].getBytes();
final InputStream in1 = new ByteArrayInputStream(bytes1);
final InputStream in2 = new ByteArrayInputStream(bytes2);
final PropertySet ps1 = PropertySetFactory.create(in1);
final PropertySet ps2 = PropertySetFactory.create(in2);
/* Compare the property set stream with the corresponding one
* from the origin file and check whether they are equal. */
assertEquals(ps1, ps2);
}
}
catch (Exception ex)
{
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
Throwable t = ex;
while (t != null)
{
t.printStackTrace(pw);
if (t instanceof HPSFRuntimeException)
t = ((HPSFRuntimeException) t).getReason();
else
t = null;
if (t != null)
pw.println("Caused by:");
}
pw.close();
try
{
sw.close();
}
catch (IOException ex2)
{
ex.printStackTrace();
}
String msg = sw.toString();
fail(msg);
}
}
/**
* <p>Creates a copy of a {@link PropertySet}.</p>
*
* @param ps the property set to copy
* @return the copy
*/
private MutablePropertySet copy(final PropertySet ps)
{
MutablePropertySet copy = new MutablePropertySet();
copy.setByteOrder(ps.getByteOrder());
copy.setClassID(ps.getClassID());
copy.setFormat(ps.getFormat());
copy.setOSVersion(ps.getOSVersion());
copy.clearSections();
/* Copy the sections. */
for (final Iterator i1 = ps.getSections().iterator(); i1.hasNext();)
{
final Section s1 = (Section) i1.next();
final MutableSection s2 = new MutableSection();
s2.setFormatID(s1.getFormatID());
/* Copy the properties. */
final Property[] pa = s1.getProperties();
for (int i2 = 0; i2 < pa.length; i2++)
{
final Property p1 = pa[i2];
final MutableProperty p2 = new MutableProperty();
p2.setID(p1.getID());
p2.setType(p1.getType());
p2.setValue(p1.getValue());
s2.setProperty(p2);
}
copy.addSection(s2);
}
return copy;
}
/**
* <p>Runs the test cases stand-alone.</p>
*/
public static void main(final String[] args) throws Throwable
{
System.setProperty("HPSF.testdata.path",
"./src/testcases/org/apache/poi/hpsf/data");
junit.textui.TestRunner.run(TestWrite.class);
}
}