public void TestWithCrazyContinueRecords()
{
// Some files have crazy ordering of their continue records
// Check that we don't break on them (bug #42844)
HSSFRequest req = new HSSFRequest();
MockHSSFListener mockListen = new MockHSSFListener();
req.AddListenerForAllRecords(mockListen);
POIFSFileSystem fs = new POIFSFileSystem(OpenSample("ContinueRecordProblem.xls"));
HSSFEventFactory factory = new HSSFEventFactory();
factory.ProcessWorkbookEvents(req, fs);
Record[] recs = mockListen.GetRecords();
// Check we got the records
Assert.IsTrue(recs.Length > 100);
// And none of them are continue ones
for (int i = 0; i < recs.Length; i++)
{
Assert.IsFalse(recs[i] is ContinueRecord);
}
// Check that the last few records are as we expect
// (Makes sure we don't accidently skip the end ones)
int numRec = recs.Length;
Assert.AreEqual(typeof(DVALRecord), recs[numRec - 3].GetType());
Assert.AreEqual(typeof(DVRecord), recs[numRec - 2].GetType());
Assert.AreEqual(typeof(EOFRecord), recs[numRec - 1].GetType());
}
public void TestOpenBOOK()
{
Stream is1 = HSSFTestDataSamples.OpenSampleFileStream(xlsB);
POIFSFileSystem fs = new POIFSFileSystem(is1);
// Ensure that we have a BOOK entry
fs.Root.GetEntry("BOOK");
Assert.IsTrue(true);
// But not a Workbook one
try
{
fs.Root.GetEntry("Workbook");
Assert.Fail();
}
catch (FileNotFoundException) { }
// And not a Summary one
try
{
fs.Root.GetEntry("\005SummaryInformation");
Assert.Fail();
}
catch (FileNotFoundException) { }
// Try to open the workbook
HSSFWorkbook wb = new HSSFWorkbook(fs);
}
public void SetUp()
{
POIFSFileSystem filesystem = new POIFSFileSystem(
POIDataSamples.GetDocumentInstance().OpenResourceAsStream("test.doc"));
DocumentEntry documentProps =
(DocumentEntry)filesystem.Root.GetEntry("WordDocument");
_mainStream = new byte[documentProps.Size];
filesystem.CreateDocumentInputStream("WordDocument").Read(_mainStream);
// use the fib to determine the name of the table stream.
_fib = new FileInformationBlock(_mainStream);
String name = "0Table";
if (_fib.IsFWhichTblStm())
{
name = "1Table";
}
// read in the table stream.
DocumentEntry tableProps =
(DocumentEntry)filesystem.Root.GetEntry(name);
_tableStream = new byte[tableProps.Size];
filesystem.CreateDocumentInputStream(name).Read(_tableStream);
_fib.FillVariableFields(_mainStream, _tableStream);
}
public void TestRecord()
{
POIFSFileSystem fs = new POIFSFileSystem(
HSSFTestDataSamples.OpenSampleFileStream("WithFormattedGraphTitle.xls"));
// Check we can Open the file via usermodel
HSSFWorkbook hssf = new HSSFWorkbook(fs);
// Now process it through eventusermodel, and
// look out for the title records
ChartTitleFormatRecordGrabber grabber = new ChartTitleFormatRecordGrabber();
Stream din = fs.CreateDocumentInputStream("Workbook");
HSSFRequest req = new HSSFRequest();
req.AddListenerForAllRecords(grabber);
HSSFEventFactory factory = new HSSFEventFactory();
factory.ProcessEvents(req, din);
din.Close();
// Should've found one
Assert.AreEqual(1, grabber.chartTitleFormatRecords.Count);
// And it should be of something interesting
AlRunsRecord r =
(AlRunsRecord)grabber.chartTitleFormatRecords[0];
Assert.AreEqual(3, r.GetFormatCount());
}
public void TestFail()
{
Stream is1 = HSSFTestDataSamples.OpenSampleFileStream("Simple.xls");
POIFSFileSystem fs = new POIFSFileSystem(is1);
HSSFWorkbook wb = new HSSFWorkbook(fs);
//set POIFS properties after constructing HSSFWorkbook
//(a piece of code that used to work up to POI 3.0.2)
SummaryInformation summary1 = (SummaryInformation)PropertySetFactory.Create(fs.CreateDocumentInputStream(SummaryInformation.DEFAULT_STREAM_NAME));
summary1.Title=(title);
//Write the modified property back to POIFS
fs.Root.GetEntry(SummaryInformation.DEFAULT_STREAM_NAME).Delete();
fs.CreateDocument(summary1.ToStream(), SummaryInformation.DEFAULT_STREAM_NAME);
//save the workbook and read the property
MemoryStream out1 = new MemoryStream();
wb.Write(out1);
out1.Close();
POIFSFileSystem fs2 = new POIFSFileSystem(new MemoryStream(out1.ToArray()));
SummaryInformation summary2 = (SummaryInformation)PropertySetFactory.Create(fs2.CreateDocumentInputStream(SummaryInformation.DEFAULT_STREAM_NAME));
//Assert.Failing assertion
Assert.AreEqual(title, summary2.Title);
}
public void Test4KBlocks()
{
Stream inp = _samples.OpenResourceAsStream("BlockSize4096.zvi");
// First up, check that we can process the header properly
HeaderBlock header_block = new HeaderBlock(inp);
POIFSBigBlockSize bigBlockSize = header_block.BigBlockSize;
Assert.AreEqual(4096, bigBlockSize.GetBigBlockSize());
// Check the fat info looks sane
Assert.AreEqual(1, header_block.BATArray.Length);
Assert.AreEqual(1, header_block.BATCount);
Assert.AreEqual(0, header_block.XBATCount);
// Now check we can get the basic fat
RawDataBlockList data_blocks = new RawDataBlockList(inp, bigBlockSize);
// Now try and open properly
POIFSFileSystem fs = new POIFSFileSystem(
_samples.OpenResourceAsStream("BlockSize4096.zvi")
);
Assert.IsTrue(fs.Root.EntryCount > 3);
// Check we can get at all the contents
CheckAllDirectoryContents(fs.Root);
// Finally, check we can do a similar 512byte one too
fs = new POIFSFileSystem(
_samples.OpenResourceAsStream("BlockSize512.zvi")
);
Assert.IsTrue(fs.Root.EntryCount > 3);
CheckAllDirectoryContents(fs.Root);
}
public void TestWrite()
{
Stream is1 = HSSFTestDataSamples.OpenSampleFileStream(xlsA);
POIFSFileSystem fs = new POIFSFileSystem(is1);
// Open the workbook, not preserving nodes
HSSFWorkbook wb = new HSSFWorkbook(fs);
MemoryStream out1 = new MemoryStream();
wb.Write(out1);
// Check now
MemoryStream in1 = new MemoryStream(out1.ToArray());
POIFSFileSystem fs2 = new POIFSFileSystem(in1);
// Check that we have the new entries
fs2.Root.GetEntry("Workbook");
try
{
fs2.Root.GetEntry("WORKBOOK");
Assert.Fail();
}
catch (FileNotFoundException) { }
// And it can be Opened
HSSFWorkbook wb2 = new HSSFWorkbook(fs2);
}
public static void ViewFile(String filename)
{
POIFSFileSystem fs = new POIFSFileSystem(
new FileStream(filename, FileMode.Open)
);
DisplayDirectory(fs.Root, "");
}
static void Main(string[] args)
{
POIFSFileSystem fs = new POIFSFileSystem();
//get the root directory
DirectoryEntry dir = fs.Root;
//create a entry of DocumentSummaryInformation
DocumentSummaryInformation dsi = PropertySetFactory.CreateDocumentSummaryInformation();
dsi.Company = "NPOI Team";
CustomProperties customProperties = dsi.CustomProperties;
if (customProperties == null)
customProperties = new CustomProperties();
customProperties.Put("测试", "value A");
customProperties.Put("BB", "value BB");
customProperties.Put("CCC", "value CCC");
dsi.CustomProperties = customProperties;
//Write the stream data of the DocumentSummaryInformation entry to the root directory
dsi.Write(dir, DocumentSummaryInformation.DEFAULT_STREAM_NAME);
//create a POIFS file called Foo.poifs
FileStream output = new FileStream("Foo.xls", FileMode.OpenOrCreate);
fs.WriteFileSystem(output);
output.Close();
}
public void TestOleNative()
{
POIFSFileSystem fs = new POIFSFileSystem(dataSamples.OpenResourceAsStream("oleObject1.bin"));
Ole10Native ole = Ole10Native.CreateFromEmbeddedOleObject(fs);
Assert.AreEqual("File1.svg", ole.Label);
Assert.AreEqual("D:\\Documents and Settings\\rsc\\My Documents\\file1.svg", ole.Command);
}
public void TestCopyRecursively()
{
POIFSFileSystem fsD = new POIFSFileSystem();
POIFSFileSystem fs = new POIFSFileSystem();
DirectoryEntry dirA = fs.CreateDirectory("DirA");
DirectoryEntry dirB = fs.CreateDirectory("DirB");
DocumentEntry entryR = fs.CreateDocument(new ByteArrayInputStream(dataSmallA), "EntryRoot");
DocumentEntry entryA1 = dirA.CreateDocument("EntryA1", new ByteArrayInputStream(dataSmallA));
DocumentEntry entryA2 = dirA.CreateDocument("EntryA2", new ByteArrayInputStream(dataSmallB));
// Copy docs
Assert.AreEqual(0, fsD.Root.EntryCount);
EntryUtils.CopyNodeRecursively(entryR, fsD.Root);
Assert.AreEqual(1, fsD.Root.EntryCount);
Assert.IsNotNull(fsD.Root.GetEntry("EntryRoot"));
EntryUtils.CopyNodeRecursively(entryA1, fsD.Root);
Assert.AreEqual(2, fsD.Root.EntryCount);
Assert.IsNotNull(fsD.Root.GetEntry("EntryRoot"));
Assert.IsNotNull(fsD.Root.GetEntry("EntryA1"));
EntryUtils.CopyNodeRecursively(entryA2, fsD.Root);
Assert.AreEqual(3, fsD.Root.EntryCount);
Assert.IsNotNull(fsD.Root.GetEntry("EntryRoot"));
Assert.IsNotNull(fsD.Root.GetEntry("EntryA1"));
Assert.IsNotNull(fsD.Root.GetEntry("EntryA2"));
// Copy directories
fsD = new POIFSFileSystem();
Assert.AreEqual(0, fsD.Root.EntryCount);
EntryUtils.CopyNodeRecursively(dirB, fsD.Root);
Assert.AreEqual(1, fsD.Root.EntryCount);
Assert.IsNotNull(fsD.Root.GetEntry("DirB"));
Assert.AreEqual(0, ((DirectoryEntry)fsD.Root.GetEntry("DirB")).EntryCount);
EntryUtils.CopyNodeRecursively(dirA, fsD.Root);
Assert.AreEqual(2, fsD.Root.EntryCount);
Assert.IsNotNull(fsD.Root.GetEntry("DirB"));
Assert.AreEqual(0, ((DirectoryEntry)fsD.Root.GetEntry("DirB")).EntryCount);
Assert.IsNotNull(fsD.Root.GetEntry("DirA"));
Assert.AreEqual(2, ((DirectoryEntry)fsD.Root.GetEntry("DirA")).EntryCount);
// Copy the whole lot
fsD = new POIFSFileSystem();
Assert.AreEqual(0, fsD.Root.EntryCount);
EntryUtils.CopyNodes(fs, fsD, new List<String>());
Assert.AreEqual(3, fsD.Root.EntryCount);
Assert.IsNotNull(fsD.Root.GetEntry(dirA.Name));
Assert.IsNotNull(fsD.Root.GetEntry(dirB.Name));
Assert.IsNotNull(fsD.Root.GetEntry(entryR.Name));
Assert.AreEqual(0, ((DirectoryEntry)fsD.Root.GetEntry("DirB")).EntryCount);
Assert.AreEqual(2, ((DirectoryEntry)fsD.Root.GetEntry("DirA")).EntryCount);
}
protected void setUp()
{
fs = new POIFSFileSystem();
dirA = fs.CreateDirectory("DirA");
dirB = fs.CreateDirectory("DirB");
dirAA = dirA.CreateDirectory("DirAA");
eRoot = fs.Root.CreateDocument("Root", new ByteArrayInputStream(new byte[] { }));
eA = dirA.CreateDocument("NA", new ByteArrayInputStream(new byte[] { }));
eAA = dirAA.CreateDocument("NAA", new ByteArrayInputStream(new byte[] { }));
}
public void TestPasswordVerification()
{
POIFSFileSystem fs = new POIFSFileSystem(POIDataSamples.GetPOIFSInstance().OpenResourceAsStream("protect.xlsx"));
EncryptionInfo info = new EncryptionInfo(fs);
Decryptor d = Decryptor.GetInstance(info);
Assert.IsTrue(d.VerifyPassword(Decryptor.DEFAULT_PASSWORD));
}
public void TestDecrypt()
{
POIFSFileSystem fs = new POIFSFileSystem(POIDataSamples.GetPOIFSInstance().OpenResourceAsStream("protect.xlsx"));
EncryptionInfo info = new EncryptionInfo(fs);
Decryptor d = Decryptor.GetInstance(info);
d.VerifyPassword(Decryptor.DEFAULT_PASSWORD);
ZipOk(fs, d);
}
public void TestEmptyConstructor()
{
POIFSFileSystem fs = new POIFSFileSystem();
DirectoryProperty property1 = new DirectoryProperty("parent");
DirectoryProperty property2 = new DirectoryProperty("child");
DirectoryNode parent = new DirectoryNode(property1, fs, null);
DirectoryNode node = new DirectoryNode(property2, fs, parent);
Assert.AreEqual(0, parent.Path.Length);
Assert.AreEqual(1, node.Path.Length);
Assert.AreEqual("child", node.Path.GetComponent(0));
// Verify that GetEntries behaves correctly
int count = 0;
IEnumerator iter = node.Entries;
while (iter.MoveNext())
{
count++;
}
Assert.AreEqual(0, count);
// Verify behavior of IsEmpty
Assert.IsTrue(node.IsEmpty);
// Verify behavior of EntryCount
Assert.AreEqual(0, node.EntryCount);
// Verify behavior of Entry
try
{
node.GetEntry("foo");
Assert.Fail("Should have caught FileNotFoundException");
}
catch (FileNotFoundException )
{
// as expected
}
// Verify behavior of isDirectoryEntry
Assert.IsTrue(node.IsDirectoryEntry);
// Verify behavior of GetName
Assert.AreEqual(property2.Name, node.Name);
// Verify behavior of isDocumentEntry
Assert.IsTrue(!node.IsDocumentEntry);
// Verify behavior of GetParent
Assert.AreEqual(parent, node.Parent);
}
public void TestAgile()
{
POIFSFileSystem fs = new POIFSFileSystem(POIDataSamples.GetPOIFSInstance().OpenResourceAsStream("protected_agile.docx"));
EncryptionInfo info = new EncryptionInfo(fs);
Assert.IsTrue(info.VersionMajor == 4 && info.VersionMinor == 4);
Decryptor d = Decryptor.GetInstance(info);
Assert.IsTrue(d.VerifyPassword(Decryptor.DEFAULT_PASSWORD));
ZipOk(fs, d);
}
static void Main(string[] args)
{
FileStream stream = new FileStream("thumbs.db", FileMode.Open, FileAccess.Read);
POIFSFileSystem poifs = new POIFSFileSystem(stream);
var entries = poifs.Root.Entries;
//POIFSDocumentReader catalogdr = poifs.CreatePOIFSDocumentReader("Catalog");
//byte[] b1=new byte[catalogdr.Length-4];
//catalogdr.Read(b1,4,b1.Length);
//Dictionary<string, string> indexList = new Dictionary<string, string>();
//for (int j = 0; j < b1.Length; j++)
//{
// if(b1[0]
//}
while (entries.MoveNext())
{
DocumentNode entry = entries.Current as DocumentNode;
DocumentInputStream dr = poifs.CreateDocumentInputStream(entry.Name);
if (entry.Name.ToLower() == "catalog")
continue;
byte[] buffer = new byte[dr.Length];
dr.Read(buffer);
int startpos = 0;
//detect jfif header
for (int i = 3; i < buffer.Length; i++)
{
if (buffer[i - 3] == 0xFF
&& buffer[i - 2] == 0xD8
&& buffer[i - 1] == 0xFF
&& buffer[i] == 0xE0)
{
startpos = i - 3;
break;
}
}
if (startpos == 0)
continue;
FileStream jpeg = File.Create(entry.Name + ".jpeg");
jpeg.Write(buffer, startpos, buffer.Length - startpos);
jpeg.Close();
}
stream.Close();
}
/**
* Write out, with any properties changes, but nothing else
*/
public override void Write(Stream out1)
{
POIFSFileSystem fs = new POIFSFileSystem();
// For tracking what we've written out, so far
List<String> excepts = new List<String>(1);
// Write out our HPFS properties, with any changes
WriteProperties(fs, excepts);
// Copy over everything else unchanged
EntryUtils.CopyNodes(directory, fs.Root, excepts);
// Save the resultant POIFSFileSystem to the output stream
fs.WriteFileSystem(out1);
}
private void OpenDocument(string path)
{
HSSFWorkbook hssfworkbook = null;
//HWPFDocument hwpf = null;
using (var stream = File.OpenRead(path))
{
try
{
_currentFileSystem = new POIFSFileSystem(stream);
//supposing every Excel file has .xls as the extension
if (path.ToLower().IndexOf(".xls")>0)
{
hssfworkbook = new HSSFWorkbook(_currentFileSystem);
}
//else if (path.ToLower().IndexOf(".doc") > 0)
//{
// hwpf =new HWPFDocument(_currentFileSystem);
//}
}
catch (Exception)
{
MessageBox.Show("Error opening file. Possibly the file is not an OLE2 Compund file.",
"Open File Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
if (_currentFileSystem != null)
{
this.Text = string.Format("POIFS Browser - {0}", path);
documentTreeView.BeginUpdate();
documentTreeView.Nodes.Clear();
TreeNode[] children=null;
if (hssfworkbook != null)
{
children = DirectoryTreeNode.GetChildren(_currentFileSystem.Root, hssfworkbook);
}
else
{
children = DirectoryTreeNode.GetChildren(_currentFileSystem.Root, null);
}
documentTreeView.Nodes.AddRange(children);
documentTreeView.EndUpdate();
}
}
static void Main(string[] args)
{
POIFSFileSystem fs = new POIFSFileSystem();
//get the root directory
DirectoryEntry dir = fs.Root;
//create a document entry
dir.CreateDocument("Foo", new MemoryStream(new byte[] {0x01,0x02,0x03 }));
//create a folder
dir.CreateDirectory("Hello");
//create a POIFS file called Foo.poifs
FileStream output = new FileStream("Foo.poifs", FileMode.OpenOrCreate);
fs.WriteFileSystem(output);
output.Close();
}
private void ZipOk(POIFSFileSystem fs, Decryptor d)
{
ZipInputStream zin = new ZipInputStream(d.GetDataStream(fs));
while (true)
{
ZipEntry entry = zin.GetNextEntry();
if (entry == null)
{
break;
}
while (zin.Available > 0)
{
zin.Skip(zin.Available);
}
}
}
public void TestEncryptionInfo1()
{
POIFSFileSystem fs = new POIFSFileSystem(POIDataSamples.GetPOIFSInstance().OpenResourceAsStream("protect.xlsx"));
EncryptionInfo info = new EncryptionInfo(fs);
Assert.AreEqual(3, info.VersionMajor);
Assert.AreEqual(2, info.VersionMinor);
Assert.AreEqual(EncryptionHeader.ALGORITHM_AES_128, info.Header.Algorithm);
Assert.AreEqual(EncryptionHeader.HASH_SHA1, info.Header.HashAlgorithm);
Assert.AreEqual(128, info.Header.KeySize);
Assert.AreEqual(EncryptionHeader.PROVIDER_AES, info.Header.ProviderType);
Assert.AreEqual("Microsoft Enhanced RSA and AES Cryptographic Provider", info.Header.CspName);
Assert.AreEqual(32, info.Verifier.VerifierHash.Length);
}
private void ProcessFile(String filename)
{
HSSFRequest req = new HSSFRequest();
mockListen = new MockHSSFListener();
listener = new FormatTrackingHSSFListener(mockListen);
req.AddListenerForAllRecords(listener);
HSSFEventFactory factory = new HSSFEventFactory();
try
{
Stream is1 = HSSFTestDataSamples.OpenSampleFileStream(filename);
POIFSFileSystem fs = new POIFSFileSystem(is1);
factory.ProcessWorkbookEvents(req, fs);
}
catch (IOException)
{
throw;
}
}
public void SetUp()
{
HSSFRequest req = new HSSFRequest();
mockListen = new MockHSSFListener();
listener = new EventWorkbookBuilder.SheetRecordCollectingListener(mockListen);
req.AddListenerForAllRecords(listener);
HSSFEventFactory factory = new HSSFEventFactory();
try
{
Stream is1 = HSSFTestDataSamples.OpenSampleFileStream("3dFormulas.xls");
POIFSFileSystem fs = new POIFSFileSystem(is1);
factory.ProcessWorkbookEvents(req, fs);
}
catch (IOException)
{
throw;
}
}
static void Main(string[] args)
{
// POI apparently can't create a document from scratch,
// so we need an existing empty dummy document
POIFSFileSystem fs = new POIFSFileSystem(File.OpenRead("empty.doc"));
HWPFDocument doc = new HWPFDocument(fs);
// centered paragraph with large font size
Range range = doc.GetRange();
CharacterRun run1 = range.InsertAfter("one");
//par1.SetSpacingAfter(200);
//par1.SetJustification((byte)1);
// justification: 0=left, 1=center, 2=right, 3=left and right
//CharacterRun run1 = par1.InsertAfter("one");
run1.SetFontSize(2 * 18);
// font size: twice the point size
// paragraph with bold typeface
Paragraph par2 = run1.InsertAfter(new ParagraphProperties(), 0);
par2.SetSpacingAfter(200);
CharacterRun run2 = par2.InsertAfter("two two two two two two two two two two two two two");
run2.SetBold(true);
// paragraph with italic typeface and a line indent in the first line
Paragraph par3 = run2.InsertAfter(new ParagraphProperties(), 0);
par3.SetFirstLineIndent(200);
par3.SetSpacingAfter(200);
CharacterRun run3 = par3.InsertAfter("three three three three three three three three three "
+ "three three three three three three three three three three three three three three "
+ "three three three three three three three three three three three three three three");
run3.SetItalic(true);
// add a custom document property (needs POI 3.5; POI 3.2 doesn't save custom properties)
DocumentSummaryInformation dsi = doc.DocumentSummaryInformation;
CustomProperties cp = dsi.CustomProperties;
if (cp == null)
cp = new CustomProperties();
cp.Put("myProperty", "foo bar baz");
doc.Write(File.OpenWrite("new-hwpf-file.doc"));
}
private void ZipOk(POIFSFileSystem fs, Decryptor d)
{
ZipInputStream zin = new ZipInputStream(d.GetDataStream(fs));
while (true)
{
int pos = zin.ReadByte();
if (pos == -1)
break;
// ZipEntry entry = zin.GetNextEntry();
// if (entry == null)
// {
// break;
// }
//while (zin.available() > 0)
//{
// zin.skip(zin.available());
//}
}
}
protected DirectoryNode[] openSamples(Stream[] inps, bool oldFails)
{
NPOIFSFileSystem nfs = new NPOIFSFileSystem(inps[0]);
if (openedFSs == null) openedFSs = new List<NPOIFSFileSystem>();
openedFSs.Add(nfs);
POIFSFileSystem ofs = null;
try
{
ofs = new POIFSFileSystem(inps[1]);
if (oldFails) Assert.Fail("POIFSFileSystem should have failed but didn't");
}
catch (Exception e)
{
if (!oldFails) throw e;
}
if (ofs == null) return new DirectoryNode[] { nfs.Root };
return new DirectoryNode[] { ofs.Root, nfs.Root };
}
private void ReadRecords(String sampleFileName)
{
HSSFRequest req = new HSSFRequest();
MockHSSFListener mockListen = new MockHSSFListener();
MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(mockListen);
req.AddListenerForAllRecords(listener);
HSSFEventFactory factory = new HSSFEventFactory();
try
{
Stream is1 = HSSFTestDataSamples.OpenSampleFileStream(sampleFileName);
POIFSFileSystem fs = new POIFSFileSystem(is1);
factory.ProcessWorkbookEvents(req, fs);
}
catch (IOException)
{
throw;
}
r = mockListen.GetRecords();
Assert.IsTrue(r.Length > 100);
}
public void TestWithMissingRecords()
{
HSSFRequest req = new HSSFRequest();
MockHSSFListener mockListen = new MockHSSFListener();
req.AddListenerForAllRecords(mockListen);
POIFSFileSystem fs = new POIFSFileSystem(OpenSample("SimpleWithSkip.xls"));
HSSFEventFactory factory = new HSSFEventFactory();
factory.ProcessWorkbookEvents(req, fs);
Record[] recs = mockListen.GetRecords();
// Check we got the records
Assert.IsTrue(recs.Length > 100);
// Check that the last few records are as we expect
// (Makes sure we don't accidently skip the end ones)
int numRec = recs.Length;
Assert.AreEqual(typeof(WindowTwoRecord), recs[numRec - 3].GetType());
Assert.AreEqual(typeof(SelectionRecord), recs[numRec - 2].GetType());
Assert.AreEqual(typeof(EOFRecord), recs[numRec - 1].GetType());
}
public void TestNormalUnicodeProperties()
{
POIFSFileSystem fs = new POIFSFileSystem(_samples.OpenResourceAsStream("TestUnicode.xls"));
HPSFPropertiesExtractor ext = new HPSFPropertiesExtractor(fs);
string text = ext.Text;
// Check each bit in turn
String sinfText = ext.SummaryInformationText;
String dinfText = ext.DocumentSummaryInformationText;
Assert.IsTrue(sinfText.IndexOf("AUTHOR = marshall") > -1);
Assert.IsTrue(sinfText.IndexOf("TITLE = Titel: \u00c4h") > -1);
Assert.IsTrue(dinfText.IndexOf("COMPANY = Schreiner") > -1);
Assert.IsTrue(dinfText.IndexOf("SCALE = False") > -1);
// Now overall
text = ext.Text;
Assert.IsTrue(text.IndexOf("AUTHOR = marshall") > -1);
Assert.IsTrue(text.IndexOf("TITLE = Titel: \u00c4h") > -1);
Assert.IsTrue(text.IndexOf("COMPANY = Schreiner") > -1);
Assert.IsTrue(text.IndexOf("SCALE = False") > -1);
}
/**
* Copies all nodes from one POIFS to the other
*
* @param source
* is the source POIFS to copy from
* @param target
* is the target POIFS to copy to
*/
public static void CopyNodes(POIFSFileSystem source,
POIFSFileSystem target)
{
CopyNodes(source.Root, target.Root);
}
public DirectoryNode(DirectoryProperty property,
POIFSFileSystem fileSystem,
DirectoryNode parent)
: this(property, parent, fileSystem, (NPOIFSFileSystem)null)
{
}
public ToxyMetadata Parse()
{
if (!System.IO.File.Exists(Context.Path))
{
throw new System.IO.FileNotFoundException("File " + Context.Path + " is not found");
}
ToxyMetadata metadata = new ToxyMetadata();
using (Stream stream = File.OpenRead(Context.Path))
{
POIFSFileSystem poifs = new NPOI.POIFS.FileSystem.POIFSFileSystem(stream);
DirectoryNode root = poifs.Root;
SummaryInformation si = null;
DocumentSummaryInformation dsi = null;
if (root.HasEntry(SummaryInformation.DEFAULT_STREAM_NAME))
{
PropertySet ps = GetPropertySet(root, SummaryInformation.DEFAULT_STREAM_NAME);
if (ps is SummaryInformation)
{
si = ps as SummaryInformation;
if (si.Author != null)
{
metadata.Add("Author", si.Author);
}
if (si.ApplicationName != null)
{
metadata.Add("ApplicationName", si.ApplicationName);
}
if (si.ClassID != null)
{
metadata.Add("ClassID", si.ClassID.ToString());
}
if (si.CharCount != 0)
{
metadata.Add("CharCount", si.CharCount);
}
if (si.ByteOrder != 0)
{
metadata.Add("ByteOrder", si.ByteOrder);
}
if (si.CreateDateTime != null)
{
metadata.Add("CreateDateTime", si.CreateDateTime);
}
if (si.LastAuthor != null)
{
metadata.Add("LastAuthor", si.LastAuthor);
}
if (si.Keywords != null)
{
metadata.Add("Keywords", si.Keywords);
}
if (si.LastPrinted != null)
{
metadata.Add("LastPrinted", si.LastPrinted);
}
if (si.LastSaveDateTime != null)
{
metadata.Add("LastSaveDateTime", si.LastSaveDateTime);
}
if (si.PageCount != 0)
{
metadata.Add("PageCount", si.PageCount);
}
if (si.WordCount != 0)
{
metadata.Add("WordCount", si.WordCount);
}
if (si.Comments != null)
{
metadata.Add("Comments", si.Comments);
}
if (si.EditTime != 0)
{
metadata.Add("EditTime", si.EditTime);
}
if (si.RevNumber != null)
{
metadata.Add("RevNumber", si.RevNumber);
}
if (si.Security != 0)
{
metadata.Add("Security", si.Security);
}
if (si.Subject != null)
{
metadata.Add("Subject", si.Subject);
}
if (si.Title != null)
{
metadata.Add("Title", si.Title);
}
if (si.Template != null)
{
metadata.Add("Template", si.Template);
}
}
}
if (root.HasEntry(DocumentSummaryInformation.DEFAULT_STREAM_NAME))
{
PropertySet ps = GetPropertySet(root, DocumentSummaryInformation.DEFAULT_STREAM_NAME);
if (ps is DocumentSummaryInformation)
{
dsi = ps as DocumentSummaryInformation;
if (dsi.ByteCount > 0)
{
metadata.Add("ByteCount", dsi.ByteCount);
}
else if (dsi.Company != null)
{
metadata.Add("Company", dsi.Company);
}
else if (dsi.Format > 0)
{
metadata.Add("Format", dsi.Format);
}
else if (dsi.LineCount > 0)
{
metadata.Add("LineCount", dsi.LineCount);
}
else if (dsi.LinksDirty)
{
metadata.Add("LinksDirty", true);
}
else if (dsi.Manager != null)
{
metadata.Add("Manager", dsi.Manager);
}
else if (dsi.NoteCount > 0)
{
metadata.Add("NoteCount", dsi.NoteCount);
}
else if (dsi.Scale)
{
metadata.Add("Scale", dsi.Scale);
}
else if (dsi.HiddenCount > 0)
{
metadata.Add("HiddenCount", dsi.Company);
}
else if (dsi.MMClipCount > 0)
{
metadata.Add("MMClipCount", dsi.MMClipCount);
}
else if (dsi.ParCount > 0)
{
metadata.Add("ParCount", dsi.ParCount);
}
}
}
}
return(metadata);
}
/// <summary>
/// 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.
/// </summary>
/// <param name="poifs">poifs POI Filesystem object</param>
/// <returns>Returns an instance of this class</returns>
public static Ole10Native CreateFromEmbeddedOleObject(POIFSFileSystem poifs)
{
return(CreateFromEmbeddedOleObject(poifs.Root));
}
