/**
* Create an InputStream from the specified DocumentEntry
*
* @param document the DocumentEntry to be read
*
* @exception IOException if the DocumentEntry cannot be opened (like, maybe it has
* been deleted?)
*/
public DocumentInputStream(DocumentEntry document)
{
if (!(document is DocumentNode))
{
throw new IOException("Cannot open internal document storage");
}
DocumentNode documentNode = (DocumentNode)document;
DirectoryNode parentNode = (DirectoryNode)document.Parent;
if (documentNode.Document != null)
{
delegate1 = new ODocumentInputStream(document);
}
else if (parentNode.FileSystem != null)
{
delegate1 = new ODocumentInputStream(document);
}
else if (parentNode.NFileSystem != null)
{
delegate1 = new NDocumentInputStream(document);
}
else
{
throw new IOException("No FileSystem bound on the parent, can't read contents");
}
}
/**
* package scoped constructor
*
* @param stream the DocumentInputStream, freshly opened
* @param path the path of the document
* @param documentName the name of the document
*/
public POIFSReaderEvent(DocumentInputStream stream,
POIFSDocumentPath path, String documentName)
{
this.stream = stream;
this.path = path;
this.documentName = documentName;
}
/**
* Copies an Entry into a target POIFS directory, recursively
*/
public static void CopyNodeRecursively(Entry entry, DirectoryEntry target)
{
// System.err.println("copyNodeRecursively called with "+entry.getName()+
// ","+target.getName());
DirectoryEntry newTarget = null;
if (entry.IsDirectoryEntry)
{
DirectoryEntry dirEntry = (DirectoryEntry)entry;
newTarget = target.CreateDirectory(entry.Name);
newTarget.StorageClsid = (dirEntry.StorageClsid);
IEnumerator <Entry> entries = dirEntry.Entries;
while (entries.MoveNext())
{
CopyNodeRecursively((Entry)entries.Current, newTarget);
}
}
else
{
DocumentEntry dentry = (DocumentEntry)entry;
DocumentInputStream dstream = new DocumentInputStream(dentry);
target.CreateDocument(dentry.Name, dstream);
dstream.Close();
}
}
/**
* Copies an Entry into a target POIFS directory, recursively
*/
public static void CopyNodeRecursively(Entry entry, DirectoryEntry target)
{
// System.err.println("copyNodeRecursively called with "+entry.GetName()+
// ","+tarGet.getName());
DirectoryEntry newTarget = null;
if (entry.IsDirectoryEntry)
{
newTarget = target.CreateDirectory(entry.Name);
IEnumerator entries = ((DirectoryEntry)entry).Entries;
while (entries.MoveNext())
{
CopyNodeRecursively((Entry)entries.Current, newTarget);
}
}
else
{
DocumentEntry dentry = (DocumentEntry)entry;
using (DocumentInputStream dstream = new DocumentInputStream(dentry))
{
target.CreateDocument(dentry.Name, dstream);
//now part of usings call to Dispose: dstream.Close();
}
}
}
/**
* Copies an Entry into a target POIFS directory, recursively
*/
public static void CopyNodeRecursively(Entry entry, DirectoryEntry target)
{
// System.err.println("copyNodeRecursively called with "+entry.getName()+
// ","+target.getName());
DirectoryEntry newTarget = null;
if (entry.IsDirectoryEntry)
{
DirectoryEntry dirEntry = (DirectoryEntry)entry;
newTarget = target.CreateDirectory(entry.Name);
newTarget.StorageClsid=(dirEntry.StorageClsid);
IEnumerator<Entry> entries = dirEntry.Entries;
while (entries.MoveNext())
{
CopyNodeRecursively((Entry)entries.Current, newTarget);
}
}
else
{
DocumentEntry dentry = (DocumentEntry)entry;
DocumentInputStream dstream = new DocumentInputStream(dentry);
target.CreateDocument(dentry.Name, dstream);
dstream.Close();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentInputStream"/> class.
/// Create an <see cref="InputStream"/> from the specified DocumentEntry
/// </summary>
/// <param name="document">the DocumentEntry to be read</param>
/// <exception cref="System.IO.IOException">
/// IOException if the DocumentEntry cannot be opened (like, maybe it has been deleted?)
/// </exception>
public DocumentInputStream(DocumentEntry document)
{
if (!(document is DocumentNode))
{
throw new IOException("Cannot open internal document storage");
}
DocumentNode documentNode = (DocumentNode)document;
DirectoryNode parentNode = (DirectoryNode)document.Parent;
if (documentNode.Document != null)
{
delegate1 = new ODocumentInputStream(document);
}
else if (parentNode.OFileSystem != null)
{
delegate1 = new ODocumentInputStream(document);
}
else if (parentNode.NFileSystem != null)
{
delegate1 = new NDocumentInputStream(document);
}
else
{
throw new IOException("No FileSystem bound on the parent, can't read contents");
}
}
public EncryptionHeader(DocumentInputStream dr)
{
flags = dr.ReadInt();
sizeExtra = dr.ReadInt();
algorithm = dr.ReadInt();
hashAlgorithm = dr.ReadInt();
keySize = dr.ReadInt();
providerType = dr.ReadInt();
dr.ReadLong(); //skip reserved.
StringBuilder builder = new StringBuilder();
while (true)
{
char c = (char)dr.ReadShort();
if (c == 0)
break;
builder.Append(c);
}
cspName = builder.ToString();
cipherMode = MODE_ECB;
keySalt = null;
}
/**
* Checks to see if two Documents have the same name
* and the same contents. (Their parent directories are
* not checked)
*/
public static bool AreDocumentsIdentical(DocumentEntry docA, DocumentEntry docB)
{
if (!docA.Name.Equals(docB.Name))
{
// Names don't match, not the same
return(false);
}
if (docA.Size != docB.Size)
{
// Wrong sizes, can't have the same contents
return(false);
}
bool matches = true;
DocumentInputStream inpA = null, inpB = null;
try
{
inpA = new DocumentInputStream(docA);
inpB = new DocumentInputStream(docB);
int readA, readB;
do
{
readA = inpA.Read();
readB = inpB.Read();
if (readA != readB)
{
matches = false;
break;
}
} while (readA != -1 && readB != -1);
}
finally
{
if (inpA != null)
{
inpA.Close();
}
if (inpB != null)
{
inpB.Close();
}
}
return(matches);
}
/**
* <p>Creates the most specific {@link PropertySet} from an entry
* in the specified POIFS Directory. This is preferrably a {@link
* DocumentSummaryInformation} or a {@link SummaryInformation}. If
* the specified entry does not contain a property Set stream, an
* exception is thrown. If no entry is found with the given name,
* an exception is thrown.</p>
*
* @param dir The directory to find the PropertySet in
* @param name The name of the entry Containing the PropertySet
* @return The Created {@link PropertySet}.
* @if there is no entry with that name
* @if the stream does not
* contain a property Set.
* @if some I/O problem occurs.
* @exception EncoderFallbackException if the specified codepage is not
* supported.
*/
public static PropertySet Create(DirectoryEntry dir, String name)
{
Stream inp = null;
try
{
DocumentEntry entry = (DocumentEntry)dir.GetEntry(name);
inp = new DocumentInputStream(entry);
try
{
return Create(inp);
}
catch (MarkUnsupportedException e) { return null; }
}
finally
{
if (inp != null) inp.Close();
}
}
/**
* Creates an instance of this class from an embedded OLE Object. The OLE Object is expected
* to include a stream "{01}Ole10Native" which Contains the actual
* data relevant for this class.
*
* @param poifs POI Filesystem object
* @return Returns an instance of this class
* @throws IOException on IO error
* @throws Ole10NativeException on invalid or unexcepted data format
*/
public static Ole10Native CreateFromEmbeddedOleObject(POIFSFileSystem poifs)
{
bool plain = false;
try
{
poifs.Root.GetEntry("\x0001Ole10ItemName");
plain = true;
}
catch (FileNotFoundException)
{
plain = false;
}
DocumentInputStream dis = poifs.CreateDocumentInputStream(OLE10_NATIVE);
using (MemoryStream bos = new MemoryStream())
{
IOUtils.Copy(dis, bos);
byte[] data = bos.ToArray();
return(new Ole10Native(data, 0, plain));
}
}
public void SetUp()
{
bout = new MemoryStream();
poifs = new POIFSFileSystem();
dir = poifs.Root;
dsi = null;
try
{
DocumentEntry dsiEntry = (DocumentEntry)
dir.GetEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME);
DocumentInputStream dis = new DocumentInputStream(dsiEntry);
PropertySet ps = new PropertySet(dis);
dis.Close();
dsi = new DocumentSummaryInformation(ps);
}
catch (FileNotFoundException)
{
/* There is no document summary information yet. We have to Create a
* new one. */
dsi = PropertySetFactory.CreateDocumentSummaryInformation();
Assert.IsNotNull(dsi);
}
catch (IOException)
{
////e.printStackTrace();
Assert.Fail();
}
catch (NoPropertySetStreamException)
{
////e.printStackTrace();
Assert.Fail();
}
catch (MarkUnsupportedException)
{
////e.printStackTrace();
Assert.Fail();
}
catch (UnexpectedPropertySetTypeException)
{
////e.printStackTrace();
Assert.Fail();
}
Assert.IsNotNull(dsi);
try
{
DocumentEntry dsiEntry = (DocumentEntry)
dir.GetEntry(SummaryInformation.DEFAULT_STREAM_NAME);
DocumentInputStream dis = new DocumentInputStream(dsiEntry);
PropertySet ps = new PropertySet(dis);
dis.Close();
si = new SummaryInformation(ps);
}
catch (FileNotFoundException)
{
/* There is no document summary information yet. We have to Create a
* new one. */
si = PropertySetFactory.CreateSummaryInformation();
Assert.IsNotNull(si);
}
catch (IOException)
{
////e.printStackTrace();
Assert.Fail();
}
catch (NoPropertySetStreamException)
{
////e.printStackTrace();
Assert.Fail();
}
catch (MarkUnsupportedException)
{
////e.printStackTrace();
Assert.Fail();
}
catch (UnexpectedPropertySetTypeException)
{
////e.printStackTrace();
Assert.Fail();
}
Assert.IsNotNull(dsi);
}
public EncryptionVerifier(DocumentInputStream dis, int encryptedLength)
{
int saltSize = dis.ReadInt();
if (saltSize != 16)
throw new Exception("Salt size != 16 !?");
salt = new byte[16];
dis.ReadFully(salt);
verifier = new byte[16];
dis.ReadFully(verifier);
verifierHashSize = dis.ReadInt();
verifierHash = new byte[encryptedLength];
dis.ReadFully(verifierHash);
spinCount = 50000;
algorithm = EncryptionHeader.ALGORITHM_AES_128;
cipherMode = EncryptionHeader.MODE_ECB;
encryptedKey = null;
}
public void TestConstructor()
{
DocumentInputStream ostream = new DocumentInputStream(_workbook_o);
DocumentInputStream nstream = new NDocumentInputStream(_workbook_n);
Assert.AreEqual(_workbook_size, _workbook_o.Size);
Assert.AreEqual(_workbook_size, _workbook_n.Size);
Assert.AreEqual(_workbook_size, ostream.Available());
Assert.AreEqual(_workbook_size, nstream.Available());
}
/**
* Create an InputStream from the specified Document
*
* @param document the Document to be read
*/
public DocumentInputStream(NPOIFSDocument document)
{
delegate1 = new NDocumentInputStream(document);
}
public void TestReadDocumentSummaryInformation()
{
POIDataSamples _samples = POIDataSamples.GetHPSFInstance();
string[] files = _samples.GetFiles("Test*.*");
for (int i = 0; i < files.Length; i++)
{
using (FileStream doc = new FileStream(files[i], FileMode.Open, FileAccess.Read))
{
Console.WriteLine("Reading file " + doc);
/* Read a Test document <em>doc</em> into a POI filesystem. */
POIFSFileSystem poifs = new POIFSFileSystem(doc);
DirectoryEntry dir = poifs.Root;
DocumentEntry dsiEntry = null;
try
{
dsiEntry = (DocumentEntry)dir.GetEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME);
}
catch (FileNotFoundException)
{
/*
* A missing document summary information stream is not an error
* and therefore silently ignored here.
*/
}
//catch (System.IO.IOException ex)
//{
// // The process cannot access the file 'testcases\test-data\hpsf\TestUnicode.xls' because it is being used by another process.
// Console.Error.WriteLine("Exception ignored (because some other test cases may read this file, too): " + ex.Message);
//}
/*
* If there is a document summry information stream, Read it from
* the POI filesystem.
*/
if (dsiEntry != null)
{
DocumentInputStream dis = new DocumentInputStream(dsiEntry);
PropertySet ps = new PropertySet(dis);
DocumentSummaryInformation dsi = new DocumentSummaryInformation(ps);
/* Execute the Get... methods. */
Console.WriteLine(dsi.ByteCount);
Console.WriteLine(dsi.ByteOrder);
Console.WriteLine(dsi.Category);
Console.WriteLine(dsi.Company);
Console.WriteLine(dsi.CustomProperties);
// FIXME Console.WriteLine(dsi.Docparts);
// FIXME Console.WriteLine(dsi.HeadingPair);
Console.WriteLine(dsi.HiddenCount);
Console.WriteLine(dsi.LineCount);
Console.WriteLine(dsi.LinksDirty);
Console.WriteLine(dsi.Manager);
Console.WriteLine(dsi.MMClipCount);
Console.WriteLine(dsi.NoteCount);
Console.WriteLine(dsi.ParCount);
Console.WriteLine(dsi.PresentationFormat);
Console.WriteLine(dsi.Scale);
Console.WriteLine(dsi.SlideCount);
}
}
}
}
public void TestReadSingleByte()
{
DocumentInputStream[] streams = new DocumentInputStream[] {
new DocumentInputStream(_workbook_o),
new NDocumentInputStream(_workbook_n)
};
foreach (DocumentInputStream stream in streams)
{
int remaining = _workbook_size;
// Try and read each byte in turn
for (int j = 0; j < _workbook_size; j++)
{
int b = stream.Read();
Assert.IsTrue(b >= 0, "Checking sign of " + j);
Assert.AreEqual(_workbook_data[j],
(byte)b, "validating byte " + j);
remaining--;
Assert.AreEqual(
remaining, stream.Available(), "Checking remaining After Reading byte " + j);
}
// Ensure we fell off the end
Assert.AreEqual(-1, stream.Read());
// Check that After close we can no longer read
stream.Close();
try
{
stream.Read();
Assert.Fail("Should have caught IOException");
}
catch (IOException)
{
// as expected
}
}
}
public ChunkedCipherInputStream(DocumentInputStream dis, long size, AgileDecryptor ag)
{
try
{
_size = size;
_stream = dis;
_ag = ag;
_cipher = _ag.GetCipher(_ag.Info.Header.Algorithm,
_ag.Info.Header.CipherMode,
_ag.SecretKey, _ag.Info.Header.KeySalt);
}
catch (System.Security.Cryptography.CryptographicException ex)
{
throw ex;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentInputStream"/> class.
/// Create an <see cref="InputStream"/> from the specified DocumentEntry
/// </summary>
/// <param name="document">the DocumentEntry to be read</param>
public DocumentInputStream(NPOIFSDocument document)
{
delegate1 = new NDocumentInputStream(document);
}
public void TestAvailable()
{
DocumentInputStream ostream = new DocumentInputStream(_workbook_o);
DocumentInputStream nstream = new NDocumentInputStream(_workbook_n);
Assert.AreEqual(_workbook_size, ostream.Available());
Assert.AreEqual(_workbook_size, nstream.Available());
ostream.Close();
nstream.Close();
try
{
ostream.Available();
Assert.Fail("Should have caught IOException");
}
catch (InvalidOperationException)
{
// as expected
}
try
{
nstream.Available();
Assert.Fail("Should have caught IOException");
}
catch (InvalidOperationException)
{
// as expected
}
}
/**
* Checks to see if two Documents have the same name
* and the same contents. (Their parent directories are
* not checked)
*/
public static bool AreDocumentsIdentical(DocumentEntry docA, DocumentEntry docB)
{
if (!docA.Name.Equals(docB.Name))
{
// Names don't match, not the same
return false;
}
if (docA.Size != docB.Size)
{
// Wrong sizes, can't have the same contents
return false;
}
bool matches = true;
DocumentInputStream inpA = null, inpB = null;
try
{
inpA = new DocumentInputStream(docA);
inpB = new DocumentInputStream(docB);
int readA, readB;
do
{
readA = inpA.Read();
readB = inpB.Read();
if (readA != readB)
{
matches = false;
break;
}
} while (readA != -1 && readB != -1);
}
finally
{
if (inpA != null) inpA.Close();
if (inpB != null) inpB.Close();
}
return matches;
}
public void TestSkip()
{
DocumentInputStream[] streams = new DocumentInputStream[] {
new DocumentInputStream(_workbook_o),
new NDocumentInputStream(_workbook_n)
};
foreach (DocumentInputStream stream in streams)
{
Assert.AreEqual(_workbook_size, stream.Available());
int count = stream.Available();
while (stream.Available() >= _buffer_size)
{
Assert.AreEqual(_buffer_size, stream.Skip(_buffer_size));
count -= _buffer_size;
Assert.AreEqual(count, stream.Available());
}
Assert.AreEqual(_workbook_size % _buffer_size,
stream.Skip(_buffer_size));
Assert.AreEqual(0, stream.Available());
stream.Reset();
Assert.AreEqual(_workbook_size, stream.Available());
Assert.AreEqual(_workbook_size, stream.Skip(_workbook_size * 2));
Assert.AreEqual(0, stream.Available());
stream.Reset();
Assert.AreEqual(_workbook_size, stream.Available());
Assert.AreEqual(_workbook_size,
stream.Skip(2 + (long)Int32.MaxValue));
Assert.AreEqual(0, stream.Available());
}
}
public void TestComplexBufferRead()
{
DocumentInputStream[] streams = new DocumentInputStream[] {
new DocumentInputStream(_workbook_o),
new NDocumentInputStream(_workbook_n)
};
foreach (DocumentInputStream stream in streams)
{
try
{
stream.Read(null, 0, 1);
Assert.Fail("Should have caught NullPointerException");
}
catch (ArgumentException)
{
// as expected
}
// test illegal offsets and lengths
try
{
stream.Read(new byte[5], -4, 0);
Assert.Fail("Should have caught IndexOutOfBoundsException");
}
catch (IndexOutOfRangeException)
{
// as expected
}
try
{
stream.Read(new byte[5], 0, -4);
Assert.Fail("Should have caught IndexOutOfBoundsException");
}
catch (IndexOutOfRangeException)
{
// as expected
}
try
{
stream.Read(new byte[5], 0, 6);
Assert.Fail("Should have caught IndexOutOfBoundsException");
}
catch (IndexOutOfRangeException)
{
// as expected
}
// test Reading zero
Assert.AreEqual(0, stream.Read(new byte[5], 0, 0));
Assert.AreEqual(_workbook_size, stream.Available());
byte[] buffer = new byte[_workbook_size];
int offset = 0;
while (stream.Available() >= _buffer_size)
{
Arrays.Fill(buffer, (byte)0);
Assert.AreEqual(_buffer_size,
stream.Read(buffer, offset, _buffer_size));
for (int j = 0; j < offset; j++)
{
Assert.AreEqual(0, buffer[j], "Checking byte " + j);
}
for (int j = offset; j < (offset + _buffer_size); j++)
{
Assert.AreEqual(_workbook_data[j],
buffer[j], "Checking byte " + j);
}
for (int j = offset + _buffer_size; j < buffer.Length; j++)
{
Assert.AreEqual(0, buffer[j], "Checking byte " + j);
}
offset += _buffer_size;
Assert.AreEqual(_workbook_size - offset,
stream.Available(), "offset " + offset);
}
Assert.AreEqual(_workbook_size % _buffer_size, stream.Available());
Arrays.Fill(buffer, (byte)0);
int count = stream.Read(buffer, offset,
_workbook_size % _buffer_size);
Assert.AreEqual(_workbook_size % _buffer_size, count);
for (int j = 0; j < offset; j++)
{
Assert.AreEqual(0, buffer[j], "Checking byte " + j);
}
for (int j = offset; j < buffer.Length; j++)
{
Assert.AreEqual(_workbook_data[j],
buffer[j], "Checking byte " + j);
}
Assert.AreEqual(_workbook_size, offset + count);
for (int j = count; j < offset; j++)
{
Assert.AreEqual(0, buffer[j], "byte " + j);
}
Assert.AreEqual(-1, stream.Read(buffer, 0, 1));
stream.Close();
try
{
stream.Read(buffer, 0, 1);
Assert.Fail("Should have caught IOException");
}
catch (IOException)
{
// as expected
}
}
}
public void TestBufferRead()
{
DocumentInputStream[] streams = new DocumentInputStream[] {
new DocumentInputStream(_workbook_o),
new NDocumentInputStream(_workbook_n)
};
foreach (DocumentInputStream stream in streams)
{
// Need to give a byte array to read
try
{
stream.Read(null);
Assert.Fail("Should have caught NullPointerException");
}
catch (NullReferenceException)
{
// as expected
}
// test Reading zero length buffer
Assert.AreEqual(0, stream.Read(new byte[0]));
Assert.AreEqual(_workbook_size, stream.Available());
byte[] buffer = new byte[_buffer_size];
int offset = 0;
while (stream.Available() >= buffer.Length)
{
Assert.AreEqual(_buffer_size, stream.Read(buffer));
for (int j = 0; j < buffer.Length; j++)
{
Assert.AreEqual(
_workbook_data[offset], buffer[j], "in main loop, byte " + offset);
offset++;
}
Assert.AreEqual(_workbook_size - offset,
stream.Available(), "offset " + offset);
}
Assert.AreEqual(_workbook_size % _buffer_size, stream.Available());
Arrays.Fill(buffer, (byte)0);
int count = stream.Read(buffer);
Assert.AreEqual(_workbook_size % _buffer_size, count);
for (int j = 0; j < count; j++)
{
Assert.AreEqual(
_workbook_data[offset], buffer[j], "past main loop, byte " + offset);
offset++;
}
Assert.AreEqual(_workbook_size, offset);
for (int j = count; j < buffer.Length; j++)
{
Assert.AreEqual(0, buffer[j], "Checking remainder, byte " + j);
}
Assert.AreEqual(-1, stream.Read(buffer));
stream.Close();
try
{
stream.Read(buffer);
Assert.Fail("Should have caught IOException");
}
catch (IOException)
{
// as expected
}
}
}
/**
* Closes the MemoryStream and Reads it into a MemoryStream.
* When finished writing information this method is used in the Tests to
* start Reading from the Created document and then the see if the results match.
*
*/
private void CloseAndReOpen()
{
try
{
dsi.Write(dir, DocumentSummaryInformation.DEFAULT_STREAM_NAME);
si.Write(dir, SummaryInformation.DEFAULT_STREAM_NAME);
}
catch (WritingNotSupportedException)
{
////e.printStackTrace();
Assert.Fail();
}
catch (IOException)
{
////e.printStackTrace();
Assert.Fail();
}
si = null;
dsi = null;
try
{
poifs.WriteFileSystem(bout);
bout.Flush();
}
catch (IOException)
{
////e.printStackTrace();
Assert.Fail();
}
Stream is1 = new MemoryStream(bout.ToArray());
Assert.IsNotNull(is1);
poifs = null;
try
{
poifs = new POIFSFileSystem(is1);
}
catch (IOException)
{
////e.printStackTrace();
Assert.Fail();
}
try
{
is1.Close();
}
catch (IOException)
{
////e.printStackTrace();
Assert.Fail();
}
Assert.IsNotNull(poifs);
/* Read the document summary information. */
dir = poifs.Root;
try
{
DocumentEntry dsiEntry = (DocumentEntry)
dir.GetEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME);
DocumentInputStream dis = new DocumentInputStream(dsiEntry);
PropertySet ps = new PropertySet(dis);
dis.Close();
dsi = new DocumentSummaryInformation(ps);
}
catch (FileNotFoundException ex)
{
Assert.Fail(ex.Message);
}
catch (IOException e)
{
//e.printStackTrace();
Assert.Fail(e.Message);
}
catch (NoPropertySetStreamException e)
{
//e.printStackTrace();
Assert.Fail(e.Message);
}
catch (MarkUnsupportedException e)
{
//e.printStackTrace();
Assert.Fail(e.Message);
}
catch (UnexpectedPropertySetTypeException e)
{
//e.printStackTrace();
Assert.Fail(e.Message);
}
try
{
DocumentEntry dsiEntry = (DocumentEntry)
dir.GetEntry(SummaryInformation.DEFAULT_STREAM_NAME);
DocumentInputStream dis = new DocumentInputStream(dsiEntry);
PropertySet ps = new PropertySet(dis);
dis.Close();
si = new SummaryInformation(ps);
}
catch (FileNotFoundException)
{
/* There is no document summary information yet. We have to Create a
* new one. */
si = PropertySetFactory.CreateSummaryInformation();
Assert.IsNotNull(si);
}
catch (IOException)
{
//e.printStackTrace();
Assert.Fail();
}
catch (NoPropertySetStreamException)
{
//e.printStackTrace();
Assert.Fail();
}
catch (MarkUnsupportedException)
{
//e.printStackTrace();
Assert.Fail();
}
catch (UnexpectedPropertySetTypeException)
{
//e.printStackTrace();
Assert.Fail();
}
}
public void TestWriteWellKnown1()
{
POIDataSamples _samples = POIDataSamples.GetHPSFInstance();
using (FileStream doc1 = _samples.GetFile(POI_FS))
{
/* Read a Test document <em>doc1</em> into a POI filesystem. */
POIFSFileSystem poifs = new POIFSFileSystem(doc1);
DirectoryEntry dir = poifs.Root;
DocumentEntry siEntry = (DocumentEntry)dir.GetEntry(SummaryInformation.DEFAULT_STREAM_NAME);
DocumentEntry dsiEntry = (DocumentEntry)dir.GetEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME);
/*
* Read the summary information stream and the document summary
* information stream from the POI filesystem.
*
* Please note that the result consists of SummaryInformation and
* DocumentSummaryInformation instances which are in memory only. To
* make them permanent they have to be written to a POI filesystem
* explicitly (overwriting the former contents). Then the POI filesystem
* should be saved to a file.
*/
DocumentInputStream dis = new DocumentInputStream(siEntry);
PropertySet ps = new PropertySet(dis);
SummaryInformation si = new SummaryInformation(ps);
dis = new DocumentInputStream(dsiEntry);
ps = new PropertySet(dis);
DocumentSummaryInformation dsi = new DocumentSummaryInformation(ps);
/*
* Write all properties supported by HPSF to the summary information
* (e.g. author, edit date, application name) and to the document
* summary information (e.g. company, manager).
*/
Calendar cal = new GregorianCalendar();
//long time1 = (long)cal.GetMilliseconds(new DateTime(2000, 6, 6, 6, 6, 6));
//long time2 = (long)cal.GetMilliseconds(new DateTime(2001, 7, 7, 7, 7, 7));
//long time3 = (long)cal.GetMilliseconds(new DateTime(2002, 8, 8, 8, 8, 8));
int nr = 4711;
String P_APPLICATION_NAME = "Microsoft Office Word";
String P_AUTHOR = "Rainer Klute";
int P_CHAR_COUNT = 125;
String P_COMMENTS = ""; //"Comments";
DateTime P_CREATE_DATE_TIME = new DateTime(2006, 2, 1, 7, 36, 0);
long P_EDIT_TIME = ++nr * 1000 * 10;
String P_KEYWORDS = "Test HPSF SummaryInformation DocumentSummaryInformation Writing";
String P_LAST_AUTHOR = "LastAuthor";
DateTime? P_LAST_PRINTED = null;
DateTime P_LAST_SAVE_DATE_TIME = new DateTime(2008, 9, 30, 9, 54, 0);
int P_PAGE_COUNT = 1;
String P_REV_NUMBER = "RevNumber";
int P_SECURITY = 1;
String P_SUBJECT = "Subject";
String P_TEMPLATE = "Normal.dotm";
// FIXME (byte array properties not yet implemented): byte[] P_THUMBNAIL = new byte[123];
String P_TITLE = "This document is used for testing POI HPSF¡¯s writing capabilities for the summary information stream and the document summary information stream";
int P_WORD_COUNT = 21;
int P_BYTE_COUNT = ++nr;
String P_CATEGORY = "Category";
String P_COMPANY = "Rainer Klute IT-Consulting GmbH";
// FIXME (byte array properties not yet implemented): byte[] P_DOCPARTS = new byte[123];
// FIXME (byte array properties not yet implemented): byte[] P_HEADING_PAIR = new byte[123];
int P_HIDDEN_COUNT = ++nr;
int P_LINE_COUNT = ++nr;
bool P_LINKS_DIRTY = true;
String P_MANAGER = "Manager";
int P_MM_CLIP_COUNT = ++nr;
int P_NOTE_COUNT = ++nr;
int P_PAR_COUNT = ++nr;
String P_PRESENTATION_FORMAT = "PresentationFormat";
bool P_SCALE = false;
int P_SLIDE_COUNT = ++nr;
DateTime now = DateTime.Now;
int POSITIVE_INTEGER = 2222;
long POSITIVE_LONG = 3333;
Double POSITIVE_DOUBLE = 4444;
int NEGATIVE_INTEGER = 2222;
long NEGATIVE_LONG = 3333;
Double NEGATIVE_DOUBLE = 4444;
int MAX_INTEGER = int.MaxValue;
int MIN_INTEGER = int.MinValue;
long MAX_LONG = long.MaxValue;
long MIN_LONG = long.MinValue;
Double MAX_DOUBLE = Double.MaxValue;
Double MIN_DOUBLE = Double.MinValue;
si.ApplicationName = P_APPLICATION_NAME;
si.Author = P_AUTHOR;
si.CharCount = P_CHAR_COUNT;
si.Comments = P_COMMENTS;
si.CreateDateTime = P_CREATE_DATE_TIME;
si.EditTime = P_EDIT_TIME;
si.Keywords = P_KEYWORDS;
si.LastAuthor = P_LAST_AUTHOR;
si.LastPrinted = P_LAST_PRINTED;
si.LastSaveDateTime = P_LAST_SAVE_DATE_TIME;
si.PageCount = P_PAGE_COUNT;
si.RevNumber = P_REV_NUMBER;
si.Security = P_SECURITY;
si.Subject = P_SUBJECT;
si.Template = P_TEMPLATE;
// FIXME (byte array properties not yet implemented): si.Thumbnail=P_THUMBNAIL;
si.Title = P_TITLE;
si.WordCount = P_WORD_COUNT;
dsi.ByteCount = P_BYTE_COUNT;
dsi.Category = P_CATEGORY;
dsi.Company = P_COMPANY;
// FIXME (byte array properties not yet implemented): dsi.Docparts=P_DOCPARTS;
// FIXME (byte array properties not yet implemented): dsi.HeadingPair=P_HEADING_PAIR;
dsi.HiddenCount = P_HIDDEN_COUNT;
dsi.LineCount = P_LINE_COUNT;
dsi.LinksDirty = P_LINKS_DIRTY;
dsi.Manager = P_MANAGER;
dsi.MMClipCount = P_MM_CLIP_COUNT;
dsi.NoteCount = P_NOTE_COUNT;
dsi.ParCount = P_PAR_COUNT;
dsi.PresentationFormat = P_PRESENTATION_FORMAT;
dsi.Scale = P_SCALE;
dsi.SlideCount = P_SLIDE_COUNT;
CustomProperties customProperties = dsi.CustomProperties;
if (customProperties == null)
customProperties = new CustomProperties();
customProperties.Put("Schlüssel 1", "Wert 1");
customProperties.Put("Schlüssel 2", "Wert 2");
customProperties.Put("Schlüssel 3", "Wert 3");
customProperties.Put("Schlüssel 4", "Wert 4");
customProperties.Put("positive_int", POSITIVE_INTEGER);
customProperties.Put("positive_long", POSITIVE_LONG);
customProperties.Put("positive_Double", POSITIVE_DOUBLE);
customProperties.Put("negative_int", NEGATIVE_INTEGER);
customProperties.Put("negative_long", NEGATIVE_LONG);
customProperties.Put("negative_Double", NEGATIVE_DOUBLE);
customProperties.Put("Boolean", true);
customProperties.Put("Date", now);
customProperties.Put("max_int", MAX_INTEGER);
customProperties.Put("min_int", MIN_INTEGER);
customProperties.Put("max_long", MAX_LONG);
customProperties.Put("min_long", MIN_LONG);
customProperties.Put("max_Double", MAX_DOUBLE);
customProperties.Put("min_Double", MIN_DOUBLE);
dsi.CustomProperties = customProperties;
/* Write the summary information stream and the document summary
* information stream to the POI filesystem. */
si.Write(dir, siEntry.Name);
dsi.Write(dir, dsiEntry.Name);
/* Write the POI filesystem to a (temporary) file <em>doc2</em>
* and Close the latter. */
using (FileStream doc2 = File.Create( @"\POI_HPSF_Test2.tmp"))
{
poifs.WriteFileSystem(doc2);
//doc2.Flush();
/*
* Open <em>doc2</em> for Reading and check summary information and
* document summary information. All properties written before must be
* found in the property streams of <em>doc2</em> and have the correct
* values.
*/
doc2.Flush();
doc2.Position = 0;
POIFSFileSystem poifs2 = new POIFSFileSystem(doc2);
dir = poifs2.Root;
siEntry = (DocumentEntry)dir.GetEntry(SummaryInformation.DEFAULT_STREAM_NAME);
dsiEntry = (DocumentEntry)dir.GetEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME);
dis = new DocumentInputStream(siEntry);
ps = new PropertySet(dis);
si = new SummaryInformation(ps);
dis = new DocumentInputStream(dsiEntry);
ps = new PropertySet(dis);
dsi = new DocumentSummaryInformation(ps);
Assert.AreEqual(P_APPLICATION_NAME, si.ApplicationName);
Assert.AreEqual(P_AUTHOR, si.Author);
Assert.AreEqual(P_CHAR_COUNT, si.CharCount);
Assert.AreEqual(P_COMMENTS, si.Comments);
Assert.AreEqual(P_CREATE_DATE_TIME, si.CreateDateTime);
Assert.AreEqual(P_EDIT_TIME, si.EditTime);
Assert.AreEqual(P_KEYWORDS, si.Keywords);
Assert.AreEqual(P_LAST_AUTHOR, si.LastAuthor);
Assert.AreEqual(P_LAST_PRINTED, si.LastPrinted);
Assert.AreEqual(P_LAST_SAVE_DATE_TIME, si.LastSaveDateTime);
Assert.AreEqual(P_PAGE_COUNT, si.PageCount);
Assert.AreEqual(P_REV_NUMBER, si.RevNumber);
Assert.AreEqual(P_SECURITY, si.Security);
Assert.AreEqual(P_SUBJECT, si.Subject);
Assert.AreEqual(P_TEMPLATE, si.Template);
// FIXME (byte array properties not yet implemented): Assert.AreEqual(P_THUMBNAIL, si.Thumbnail);
Assert.AreEqual(P_TITLE, si.Title);
Assert.AreEqual(P_WORD_COUNT, si.WordCount);
Assert.AreEqual(P_BYTE_COUNT, dsi.ByteCount);
Assert.AreEqual(P_CATEGORY, dsi.Category);
Assert.AreEqual(P_COMPANY, dsi.Company);
// FIXME (byte array properties not yet implemented): Assert.AreEqual(P_, dsi.Docparts);
// FIXME (byte array properties not yet implemented): Assert.AreEqual(P_, dsi.HeadingPair);
Assert.AreEqual(P_HIDDEN_COUNT, dsi.HiddenCount);
Assert.AreEqual(P_LINE_COUNT, dsi.LineCount);
Assert.AreEqual(P_LINKS_DIRTY, dsi.LinksDirty);
Assert.AreEqual(P_MANAGER, dsi.Manager);
Assert.AreEqual(P_MM_CLIP_COUNT, dsi.MMClipCount);
Assert.AreEqual(P_NOTE_COUNT, dsi.NoteCount);
Assert.AreEqual(P_PAR_COUNT, dsi.ParCount);
Assert.AreEqual(P_PRESENTATION_FORMAT, dsi.PresentationFormat);
Assert.AreEqual(P_SCALE, dsi.Scale);
Assert.AreEqual(P_SLIDE_COUNT, dsi.SlideCount);
CustomProperties cps = dsi.CustomProperties;
//Assert.AreEqual(customProperties, cps);
Assert.IsNull(cps["No value available"]);
Assert.AreEqual("Wert 1", cps["Schlüssel 1"]);
Assert.AreEqual("Wert 2", cps["Schlüssel 2"]);
Assert.AreEqual("Wert 3", cps["Schlüssel 3"]);
Assert.AreEqual("Wert 4", cps["Schlüssel 4"]);
Assert.AreEqual(POSITIVE_INTEGER, cps["positive_int"]);
Assert.AreEqual(POSITIVE_LONG, cps["positive_long"]);
Assert.AreEqual(POSITIVE_DOUBLE, cps["positive_Double"]);
Assert.AreEqual(NEGATIVE_INTEGER, cps["negative_int"]);
Assert.AreEqual(NEGATIVE_LONG, cps["negative_long"]);
Assert.AreEqual(NEGATIVE_DOUBLE, cps["negative_Double"]);
Assert.AreEqual(true, cps["Boolean"]);
Assert.AreEqual(now, cps["Date"]);
Assert.AreEqual(MAX_INTEGER, cps["max_int"]);
Assert.AreEqual(MIN_INTEGER, cps["min_int"]);
Assert.AreEqual(MAX_LONG, cps["max_long"]);
Assert.AreEqual(MIN_LONG, cps["min_long"]);
Assert.AreEqual(MAX_DOUBLE, cps["max_Double"]);
Assert.AreEqual(MIN_DOUBLE, cps["min_Double"]);
/* Remove all properties supported by HPSF from the summary
* information (e.g. author, edit date, application name) and from the
* document summary information (e.g. company, manager). */
si.RemoveApplicationName();
si.RemoveAuthor();
si.RemoveCharCount();
si.RemoveComments();
si.RemoveCreateDateTime();
si.RemoveEditTime();
si.RemoveKeywords();
si.RemoveLastAuthor();
si.RemoveLastPrinted();
si.RemoveLastSaveDateTime();
si.RemovePageCount();
si.RemoveRevNumber();
si.RemoveSecurity();
si.RemoveSubject();
si.RemoveTemplate();
si.RemoveThumbnail();
si.RemoveTitle();
si.RemoveWordCount();
dsi.RemoveByteCount();
dsi.RemoveCategory();
dsi.RemoveCompany();
dsi.RemoveCustomProperties();
dsi.RemoveDocparts();
dsi.RemoveHeadingPair();
dsi.RemoveHiddenCount();
dsi.RemoveLineCount();
dsi.RemoveLinksDirty();
dsi.RemoveManager();
dsi.RemoveMMClipCount();
dsi.RemoveNoteCount();
dsi.RemoveParCount();
dsi.RemovePresentationFormat();
dsi.RemoveScale();
dsi.RemoveSlideCount();
/*
* <li>Write the summary information stream and the document summary
* information stream to the POI filesystem. */
si.Write(dir, siEntry.Name);
dsi.Write(dir, dsiEntry.Name);
/*
* <li>Write the POI filesystem to a (temporary) file <em>doc3</em>
* and Close the latter. */
using (FileStream doc3 = File.Create( @"\POI_HPSF_Test3.tmp"))
{
poifs2.WriteFileSystem(doc3);
doc3.Position = 0;
/*
* Open <em>doc3</em> for Reading and check summary information
* and document summary information. All properties Removed before must not
* be found in the property streams of <em>doc3</em>.
*/
POIFSFileSystem poifs3 = new POIFSFileSystem(doc3);
dir = poifs3.Root;
siEntry = (DocumentEntry)dir.GetEntry(SummaryInformation.DEFAULT_STREAM_NAME);
dsiEntry = (DocumentEntry)dir.GetEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME);
dis = new DocumentInputStream(siEntry);
ps = new PropertySet(dis);
si = new SummaryInformation(ps);
dis = new DocumentInputStream(dsiEntry);
ps = new PropertySet(dis);
dsi = new DocumentSummaryInformation(ps);
Assert.AreEqual(null, si.ApplicationName);
Assert.AreEqual(null, si.Author);
Assert.AreEqual(0, si.CharCount);
Assert.IsTrue(si.WasNull);
Assert.AreEqual(null, si.Comments);
Assert.AreEqual(null, si.CreateDateTime);
Assert.AreEqual(0, si.EditTime);
Assert.IsTrue(si.WasNull);
Assert.AreEqual(null, si.Keywords);
Assert.AreEqual(null, si.LastAuthor);
Assert.AreEqual(null, si.LastPrinted);
Assert.AreEqual(null, si.LastSaveDateTime);
Assert.AreEqual(0, si.PageCount);
Assert.IsTrue(si.WasNull);
Assert.AreEqual(null, si.RevNumber);
Assert.AreEqual(0, si.Security);
Assert.IsTrue(si.WasNull);
Assert.AreEqual(null, si.Subject);
Assert.AreEqual(null, si.Template);
Assert.AreEqual(null, si.Thumbnail);
Assert.AreEqual(null, si.Title);
Assert.AreEqual(0, si.WordCount);
Assert.IsTrue(si.WasNull);
Assert.AreEqual(0, dsi.ByteCount);
Assert.IsTrue(dsi.WasNull);
Assert.AreEqual(null, dsi.Category);
Assert.AreEqual(null, dsi.CustomProperties);
// FIXME (byte array properties not yet implemented): Assert.AreEqual(null, dsi.Docparts);
// FIXME (byte array properties not yet implemented): Assert.AreEqual(null, dsi.HeadingPair);
Assert.AreEqual(0, dsi.HiddenCount);
Assert.IsTrue(dsi.WasNull);
Assert.AreEqual(0, dsi.LineCount);
Assert.IsTrue(dsi.WasNull);
Assert.AreEqual(false, dsi.LinksDirty);
Assert.IsTrue(dsi.WasNull);
Assert.AreEqual(null, dsi.Manager);
Assert.AreEqual(0, dsi.MMClipCount);
Assert.IsTrue(dsi.WasNull);
Assert.AreEqual(0, dsi.NoteCount);
Assert.IsTrue(dsi.WasNull);
Assert.AreEqual(0, dsi.ParCount);
Assert.IsTrue(dsi.WasNull);
Assert.AreEqual(null, dsi.PresentationFormat);
Assert.AreEqual(false, dsi.Scale);
Assert.IsTrue(dsi.WasNull);
Assert.AreEqual(0, dsi.SlideCount);
Assert.IsTrue(dsi.WasNull);
}
}
}
File.Delete( @"\POI_HPSF_Test3.tmp");
File.Delete( @"\POI_HPSF_Test2.tmp");
}
private void RunTest(FileStream file)
{
/* Read a Test document <em>doc</em> into a POI filesystem. */
POIFSFileSystem poifs = new POIFSFileSystem(file);
DirectoryEntry dir = poifs.Root;
DocumentEntry dsiEntry = null;
try
{
dsiEntry = (DocumentEntry)dir.GetEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME);
}
catch (FileNotFoundException)
{
/*
* A missing document summary information stream is not an error
* and therefore silently ignored here.
*/
}
/*
* If there is a document summry information stream, Read it from
* the POI filesystem, else Create a new one.
*/
DocumentSummaryInformation dsi;
if (dsiEntry != null)
{
DocumentInputStream dis = new DocumentInputStream(dsiEntry);
PropertySet ps = new PropertySet(dis);
dsi = new DocumentSummaryInformation(ps);
}
else
dsi = PropertySetFactory.CreateDocumentSummaryInformation();
CustomProperties cps = dsi.CustomProperties;
if (cps == null)
/* The document does not have custom properties. */
return;
foreach (DictionaryEntry de in cps )
{
CustomProperty cp = (CustomProperty)de.Value;
Assert.IsNotNull(cp.Name);
Assert.IsNotNull(cp.Value);
}
}
private void CheckAllDirectoryContents(DirectoryEntry dir)
{
IEnumerator<Entry> it = dir.Entries;
//foreach (Entry entry in dir)
while (it.MoveNext())
{
Entry entry = it.Current;
if (entry is DirectoryEntry)
{
CheckAllDirectoryContents((DirectoryEntry)entry);
}
else
{
DocumentNode doc = (DocumentNode)entry;
DocumentInputStream dis = new DocumentInputStream(doc);
try
{
int numBytes = dis.Available();
byte[] data = new byte[numBytes];
dis.Read(data);
}
finally
{
dis.Close();
}
}
}
}
public void TestMarkFunctions()
{
byte[] buffer = new byte[_workbook_size / 5];
byte[] small_buffer = new byte[212];
DocumentInputStream[] streams = new DocumentInputStream[] {
new DocumentInputStream(_workbook_o),
new NDocumentInputStream(_workbook_n)
};
foreach (DocumentInputStream stream in streams)
{
// Read a fifth of it, and check all's correct
stream.Read(buffer);
for (int j = 0; j < buffer.Length; j++)
{
Assert.AreEqual(_workbook_data[j], buffer[j], "Checking byte " + j);
}
Assert.AreEqual(_workbook_size - buffer.Length, stream.Available());
// Reset, and check the available goes back to being the
// whole of the stream
stream.Reset();
Assert.AreEqual(_workbook_size, stream.Available());
// Read part of a block
stream.Read(small_buffer);
for (int j = 0; j < small_buffer.Length; j++)
{
Assert.AreEqual(_workbook_data[j], small_buffer[j], "Checking byte " + j);
}
Assert.AreEqual(_workbook_size - small_buffer.Length, stream.Available());
stream.Mark(0);
// Read the next part
stream.Read(small_buffer);
for (int j = 0; j < small_buffer.Length; j++)
{
Assert.AreEqual(_workbook_data[j + small_buffer.Length], small_buffer[j], "Checking byte " + j);
}
Assert.AreEqual(_workbook_size - 2 * small_buffer.Length, stream.Available());
// Reset, check it goes back to where it was
stream.Reset();
Assert.AreEqual(_workbook_size - small_buffer.Length, stream.Available());
// Read
stream.Read(small_buffer);
for (int j = 0; j < small_buffer.Length; j++)
{
Assert.AreEqual(_workbook_data[j + small_buffer.Length], small_buffer[j], "Checking byte " + j);
}
Assert.AreEqual(_workbook_size - 2 * small_buffer.Length, stream.Available());
// Now read at various points
Arrays.Fill(small_buffer, (byte)0);
stream.Read(small_buffer, 6, 8);
stream.Read(small_buffer, 100, 10);
stream.Read(small_buffer, 150, 12);
int pos = small_buffer.Length * 2;
for (int j = 0; j < small_buffer.Length; j++)
{
byte exp = 0;
if (j >= 6 && j < 6 + 8)
{
exp = _workbook_data[pos];
pos++;
}
if (j >= 100 && j < 100 + 10)
{
exp = _workbook_data[pos];
pos++;
}
if (j >= 150 && j < 150 + 12)
{
exp = _workbook_data[pos];
pos++;
}
Assert.AreEqual(exp, small_buffer[j], "Checking byte " + j);
}
}
// Now repeat it with spanning multiple blocks
streams = new DocumentInputStream[] {
new DocumentInputStream(_workbook_o),
new NDocumentInputStream(_workbook_n) };
foreach (DocumentInputStream stream in streams)
{
// Read several blocks work
buffer = new byte[_workbook_size / 5];
stream.Read(buffer);
for (int j = 0; j < buffer.Length; j++)
{
Assert.AreEqual(_workbook_data[j], buffer[j], "Checking byte " + j);
}
Assert.AreEqual(_workbook_size - buffer.Length, stream.Available());
// Read all of it again, check it began at the start again
stream.Reset();
Assert.AreEqual(_workbook_size, stream.Available());
stream.Read(buffer);
for (int j = 0; j < buffer.Length; j++)
{
Assert.AreEqual(_workbook_data[j], buffer[j], "Checking byte " + j);
}
// Mark our position, and read another whole buffer
stream.Mark(12);
stream.Read(buffer);
Assert.AreEqual(_workbook_size - (2 * buffer.Length),
stream.Available());
for (int j = buffer.Length; j < (2 * buffer.Length); j++)
{
Assert.AreEqual(_workbook_data[j], buffer[j - buffer.Length], "Checking byte " + j);
}
// Reset, should go back to only one buffer full read
stream.Reset();
Assert.AreEqual(_workbook_size - buffer.Length, stream.Available());
// Read the buffer again
stream.Read(buffer);
Assert.AreEqual(_workbook_size - (2 * buffer.Length),
stream.Available());
for (int j = buffer.Length; j < (2 * buffer.Length); j++)
{
Assert.AreEqual(_workbook_data[j], buffer[j - buffer.Length], "Checking byte " + j);
}
Assert.IsTrue(stream.MarkSupported());
}
}
