public void Test53475() { try { Biff8EncryptionKey.CurrentUserPassword = (/*setter*/"solrcell"); FileStream file = POIDataSamples.GetDocumentInstance().GetFile("bug53475-password-is-solrcell.docx"); NPOIFSFileSystem filesystem = new NPOIFSFileSystem(file, true); /* // Check the encryption details EncryptionInfo info = new EncryptionInfo(filesystem); Assert.AreEqual(128, info.Header.KeySize); Assert.AreEqual(EncryptionHeader.ALGORITHM_AES_128, info.Header.Algorithm); Assert.AreEqual(EncryptionHeader.HASH_SHA1, info.Header.HashAlgorithm); // Check it can be decoded Decryptor d = Decryptor.GetInstance(info); Assert.IsTrue("Unable to Process: document is encrypted", d.VerifyPassword("solrcell")); // Check we can read the word document in that InputStream dataStream = d.GetDataStream(filesystem); OPCPackage opc = OPCPackage.Open(dataStream); XWPFDocument doc = new XWPFDocument(opc); XWPFWordExtractor ex = new XWPFWordExtractor(doc); String text = ex.Text; Assert.IsNotNull(text); Assert.AreEqual("This is password protected Word document.", text.Trim()); ex.Close(); */ } finally { Biff8EncryptionKey.CurrentUserPassword = (/*setter*/null); } }
public NPOIFSDocument(String name, int size, NPOIFSFileSystem filesystem, POIFSWriterListener Writer) { this._filesystem = filesystem; if (size < POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE) { _stream = new NPOIFSStream(filesystem.GetMiniStore()); _block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize(); } else { _stream = new NPOIFSStream(filesystem); _block_size = _filesystem.GetBlockStoreBlockSize(); } Stream innerOs = _stream.GetOutputStream(); DocumentOutputStream os = new DocumentOutputStream(innerOs, size); POIFSDocumentPath path = new POIFSDocumentPath(name.Split(new string[] { "\\\\" }, StringSplitOptions.RemoveEmptyEntries)); String docName = path.GetComponent(path.Length - 1); POIFSWriterEvent event1 = new POIFSWriterEvent(os, path, docName, size); Writer.ProcessPOIFSWriterEvent(event1); innerOs.Close(); // And build the property for it this._property = new DocumentProperty(name, size); _property.StartBlock = (/*setter*/ _stream.GetStartBlock()); }
public NPropertyTable(HeaderBlock headerBlock, NPOIFSFileSystem fileSystem) :base(headerBlock, BuildProperties( (new NPOIFSStream(fileSystem, headerBlock.PropertyStart)).GetEnumerator(),headerBlock.BigBlockSize) ) { _bigBigBlockSize = headerBlock.BigBlockSize; }
/** * Copies nodes from one POIFS to the other, minus the excepts. * This delegates the filtering work to {@link FilteringDirectoryNode}, * so excepts can be of the form "NodeToExclude" or * "FilteringDirectory/ExcludedChildNode" * * @param source is the source POIFS to copy from * @param target is the target POIFS to copy to * @param excepts is a list of Entry Names to be excluded from the copy */ public static void CopyNodes(NPOIFSFileSystem source, NPOIFSFileSystem target, List <String> excepts) { CopyNodes( new FilteringDirectoryNode(source.Root, excepts), new FilteringDirectoryNode(target.Root, excepts) ); }
/** * Returns test files with 512 byte and 4k block sizes, loaded * both from InputStreams and Files */ protected NPOIFSFileSystem[] get512and4kFileAndInput() { NPOIFSFileSystem fsA = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi")); NPOIFSFileSystem fsB = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); NPOIFSFileSystem fsC = new NPOIFSFileSystem(_inst.GetFile("BlockSize4096.zvi")); NPOIFSFileSystem fsD = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize4096.zvi")); return new NPOIFSFileSystem[] { fsA, fsB, fsC, fsD }; }
public NPOIFSMiniStore(NPOIFSFileSystem filesystem, RootProperty root, List<BATBlock> sbats, HeaderBlock header) { this._filesystem = filesystem; this._sbat_blocks = sbats; this._header = header; this._root = root; this._mini_stream = new NPOIFSStream(filesystem, root.StartBlock); }
/** * Constructor for a new Document * * @param name the name of the POIFSDocument * @param stream the InputStream we read data from */ public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, Stream stream) { this._filesystem = filesystem; // sotre it int length = Store(stream); // Build the property for it this._property = new DocumentProperty(name, length); _property.StartBlock = _stream.GetStartBlock(); }
public NPOIFSMiniStore(NPOIFSFileSystem filesystem, RootProperty root, List <BATBlock> sbats, HeaderBlock header) { this._filesystem = filesystem; this._sbat_blocks = sbats; this._header = header; this._root = root; this._mini_stream = new NPOIFSStream(filesystem, root.StartBlock); }
/** * Constructor for a new Document * * @param name the name of the POIFSDocument * @param stream the InputStream we read data from */ public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, Stream stream) { this._filesystem = filesystem; // sotre it int length = Store(stream); // Build the property for it this._property = new DocumentProperty(name, length); _property.StartBlock = _stream.GetStartBlock(); }
/** * Constructor for an existing Document */ public NPOIFSDocument(DocumentProperty property, NPOIFSFileSystem filesystem) { this._property = property; this._filesystem = filesystem; if (property.Size < POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE) { _stream = new NPOIFSStream(_filesystem.GetMiniStore(), property.StartBlock); _block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize(); } else { _stream = new NPOIFSStream(_filesystem, property.StartBlock); _block_size = _filesystem.GetBlockStoreBlockSize(); } }
/** * Constructor for an existing Document */ public NPOIFSDocument(DocumentProperty property, NPOIFSFileSystem filesystem) { this._property = property; this._filesystem = filesystem; if (property.Size < POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE) { _stream = new NPOIFSStream(_filesystem.GetMiniStore(), property.StartBlock); _block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize(); } else { _stream = new NPOIFSStream(_filesystem, property.StartBlock); _block_size = _filesystem.GetBlockStoreBlockSize(); } }
private DirectoryNode(DirectoryProperty property, DirectoryNode parent, POIFSFileSystem oFileSystem, NPOIFSFileSystem nFileSystem) : base(property, parent) { this._oFilesSystem = oFileSystem; this._nFilesSystem = nFileSystem; if (parent == null) { _path = new POIFSDocumentPath(); } else { _path = new POIFSDocumentPath(parent._path, new string[] { property.Name }); } _byname = new Dictionary <string, Entry>(); _entries = new List <Entry>(); IEnumerator <Property> iter = property.Children; while (iter.MoveNext()) { Property child = iter.Current; Entry childNode = null; if (child.IsDirectory) { DirectoryProperty childDir = (DirectoryProperty)child; if (_oFilesSystem != null) { childNode = new DirectoryNode(childDir, _oFilesSystem, this); } else { childNode = new DirectoryNode(childDir, _nFilesSystem, this); } } else { childNode = new DocumentNode((DocumentProperty)child, this); } _entries.Add(childNode); _byname.Add(childNode.Name, childNode); } }
protected static void assertBATCount(NPOIFSFileSystem fs, int expectedBAT, int expectedXBAT) { int foundBAT = 0; int foundXBAT = 0; int sz = (int)(fs.Size / fs.GetBigBlockSize()); for (int i = 0; i < sz; i++) { if (fs.GetNextBlock(i) == POIFSConstants.FAT_SECTOR_BLOCK) { foundBAT++; } if (fs.GetNextBlock(i) == POIFSConstants.DIFAT_SECTOR_BLOCK) { foundXBAT++; } } Assert.AreEqual(expectedBAT, foundBAT, "Wrong number of BATs"); Assert.AreEqual(expectedXBAT, foundXBAT, "Wrong number of XBATs with " + expectedBAT + " BATs"); }
public void TestBasicOpen() { NPOIFSFileSystem fsA, fsB; fsA = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi")); fsB = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); foreach (NPOIFSFileSystem fs in new NPOIFSFileSystem[] { fsA, fsB }) { Assert.AreEqual(512, fs.GetBigBlockSize()); } fsA = new NPOIFSFileSystem(_inst.GetFile("BlockSize4096.zvi")); fsB = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize4096.zvi")); foreach (NPOIFSFileSystem fs in new NPOIFSFileSystem[] { fsA, fsB }) { Assert.AreEqual(4096, fs.GetBigBlockSize()); } }
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 }; }
public void TestReadTinyStream() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi")); // 98 is actually the last block in a two block stream... NPOIFSStream stream = new NPOIFSStream(fs, 98); IEnumerator<ByteBuffer> i = stream.GetBlockIterator(); Assert.AreEqual(true, i.MoveNext()); ByteBuffer b = i.Current; Assert.AreEqual(false, i.MoveNext()); // Check the contents Assert.AreEqual((byte)0x81, b[0]); Assert.AreEqual((byte)0x00, b[1]); Assert.AreEqual((byte)0x00, b[2]); Assert.AreEqual((byte)0x00, b[3]); Assert.AreEqual((byte)0x82, b[4]); Assert.AreEqual((byte)0x00, b[5]); Assert.AreEqual((byte)0x00, b[6]); Assert.AreEqual((byte)0x00, b[7]); }
public void TestReadShortStream() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi")); // 97 -> 98 -> end NPOIFSStream stream = new NPOIFSStream(fs, 97); IEnumerator<ByteBuffer> i = stream.GetBlockIterator(); Assert.AreEqual(true, i.MoveNext()); // i.MoveNext(); ByteBuffer b97 = i.Current; Assert.AreEqual(true, i.MoveNext()); //i.MoveNext(); ByteBuffer b98 = i.Current; Assert.AreEqual(false, i.MoveNext()); // Check the contents of the 1st block Assert.AreEqual((byte)0x01, b97[0]); Assert.AreEqual((byte)0x00, b97[1]); Assert.AreEqual((byte)0x00, b97[2]); Assert.AreEqual((byte)0x00, b97[3]); Assert.AreEqual((byte)0x02, b97[4]); Assert.AreEqual((byte)0x00, b97[5]); Assert.AreEqual((byte)0x00, b97[6]); Assert.AreEqual((byte)0x00, b97[7]); // Check the contents of the 2nd block Assert.AreEqual((byte)0x81, b98[0]); Assert.AreEqual((byte)0x00, b98[1]); Assert.AreEqual((byte)0x00, b98[2]); Assert.AreEqual((byte)0x00, b98[3]); Assert.AreEqual((byte)0x82, b98[4]); Assert.AreEqual((byte)0x00, b98[5]); Assert.AreEqual((byte)0x00, b98[6]); Assert.AreEqual((byte)0x00, b98[7]); fs.Close(); }
public void TestReadFailsOnLoop() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi")); // Hack the FAT so that it goes 0->1->2->0 fs.SetNextBlock(0, 1); fs.SetNextBlock(1, 2); fs.SetNextBlock(2, 0); // Now try to read NPOIFSStream stream = new NPOIFSStream(fs, 0); IEnumerator<ByteBuffer> i = stream.GetBlockIterator(); //1st read works Assert.AreEqual(true, i.MoveNext()); // 1st read works // i.MoveNext(); // 2nd read works Assert.AreEqual(true, i.MoveNext()); // i.MoveNext(); // Assert.AreEqual(true, i.MoveNext()); // 3rd read works //i.MoveNext(); Assert.AreEqual(true, i.MoveNext()); // 4th read blows up as it loops back to 0 try { i.MoveNext(); Assert.AreEqual(true, i.MoveNext()); Assert.Fail("Loop should have been detected but wasn't!"); } catch (Exception) { // Good, it was detected } // Assert.AreEqual(true, i.MoveNext()); }
/** * Constructor for a new Document * * @param name the name of the POIFSDocument * @param stream the InputStream we read data from */ public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, Stream stream) { this._filesystem = filesystem; // Buffer the contents into memory. This is a bit icky... // TODO Replace with a buffer up to the mini stream size, then streaming write byte[] contents; if (stream is MemoryStream) { MemoryStream bais = (MemoryStream)stream; contents = new byte[bais.Length]; bais.Read(contents, 0, contents.Length); } else { MemoryStream baos = new MemoryStream(); IOUtils.Copy(stream, baos); contents = baos.ToArray(); } // Do we need to store as a mini stream or a full one? if (contents.Length <= POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE) { _stream = new NPOIFSStream(filesystem.GetMiniStore()); _block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize(); } else { _stream = new NPOIFSStream(filesystem); _block_size = _filesystem.GetBlockStoreBlockSize(); } // Store it _stream.UpdateContents(contents); // And build the property for it this._property = new DocumentProperty(name, contents.Length); _property.StartBlock = _stream.GetStartBlock(); }
/** * Constructor for a new Document * * @param name the name of the POIFSDocument * @param stream the InputStream we read data from */ public NPOIFSDocument(String name, NPOIFSFileSystem filesystem, Stream stream) { this._filesystem = filesystem; // Buffer the contents into memory. This is a bit icky... // TODO Replace with a buffer up to the mini stream size, then streaming write byte[] contents; if (stream is MemoryStream) { MemoryStream bais = (MemoryStream)stream; contents = new byte[bais.Length]; bais.Read(contents, 0, contents.Length); } else { MemoryStream baos = new MemoryStream(); IOUtils.Copy(stream, baos); contents = baos.ToArray(); } // Do we need to store as a mini stream or a full one? if (contents.Length <= POIFSConstants.BIG_BLOCK_MINIMUM_DOCUMENT_SIZE) { _stream = new NPOIFSStream(filesystem.GetMiniStore()); _block_size = _filesystem.GetMiniStore().GetBlockStoreBlockSize(); } else { _stream = new NPOIFSStream(filesystem); _block_size = _filesystem.GetBlockStoreBlockSize(); } // Store it _stream.UpdateContents(contents); // And build the property for it this._property = new DocumentProperty(name, contents.Length); _property.StartBlock = _stream.GetStartBlock(); }
/// <summary> /// Wrap the OLE2 data in the NPOIFSFileSystem into a decrypted stream by using the given password. /// </summary> /// <param name="fs">The OLE2 stream for the document</param> /// <param name="password">The password, null if the default password should be used</param> /// <returns>A stream for reading the decrypted data</returns> /// <exception cref="System.IO.IOException">If an error occurs while decrypting or if the password does not match</exception> public static InputStream GetDecryptedStream(NPOIFSFileSystem fs, String password) { EncryptionInfo info = new EncryptionInfo(fs); Decryptor d = Decryptor.GetInstance(info); try { bool passwordCorrect = false; if (password != null && d.VerifyPassword(password)) { passwordCorrect = true; } if (!passwordCorrect && d.VerifyPassword(Decryptor.DEFAULT_PASSWORD)) { passwordCorrect = true; } if (passwordCorrect) { return(new FilterInputStream1(d.GetDataStream(fs.Root), fs)); } else { if (password != null) { throw new EncryptedDocumentException("Password incorrect"); } else { throw new EncryptedDocumentException("The supplied spreadsheet is protected, but no password was supplied"); } } } catch (Exception e) { throw new IOException("password does not match", e); } }
public void TestFiles() { FileStream[] files = { // bug 51891 POIDataSamples.GetPOIFSInstance().GetFile("multimedia.doc"), // tika bug 1072 POIDataSamples.GetPOIFSInstance().GetFile("20-Force-on-a-current-S00.doc"), // other files Containing ole10native records ... POIDataSamples.GetDocumentInstance().GetFile("Bug53380_3.doc"), POIDataSamples.GetDocumentInstance().GetFile("Bug47731.doc") }; foreach (FileStream f in files) { NPOIFSFileSystem fs = new NPOIFSFileSystem(f,null, true, true); List<Entry> entries = new List<Entry>(); FindOle10(entries, fs.Root, "/", ""); foreach (Entry e in entries) { MemoryStream bosExp = new MemoryStream(); Stream is1 = ((DirectoryNode)e.Parent).CreateDocumentInputStream(e); IOUtils.Copy(is1, bosExp); is1.Close(); Ole10Native ole = Ole10Native.CreateFromEmbeddedOleObject((DirectoryNode)e.Parent); MemoryStream bosAct = new MemoryStream(); ole.WriteOut(bosAct); //assertThat(bosExp.ToByteArray(), EqualTo(bosAct.ToByteArray())); Assert.IsTrue(Arrays.Equals(bosExp.ToArray(), bosAct.ToArray())); } fs.Close(); } }
/// <summary> /// Create a DirectoryNode. This method Is not public by design; it /// Is intended strictly for the internal use of this package /// </summary> /// <param name="property">the DirectoryProperty for this DirectoryEntry</param> /// <param name="nFileSystem">the POIFSFileSystem we belong to</param> /// <param name="parent">the parent of this entry</param> public DirectoryNode(DirectoryProperty property, NPOIFSFileSystem nFileSystem, DirectoryNode parent) : this(property, parent, (POIFSFileSystem)null, nFileSystem) { }
public void TestReadLongerStream() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi")); ByteBuffer b0 = null; ByteBuffer b1 = null; ByteBuffer b22 = null; // The stream at 0 has 23 blocks in it NPOIFSStream stream = new NPOIFSStream(fs, 0); IEnumerator<ByteBuffer> i = stream.GetBlockIterator(); int count = 0; while (i.MoveNext()) { ByteBuffer b = i.Current; if (count == 0) { b0 = b; } if (count == 1) { b1 = b; } if (count == 22) { b22 = b; } count++; } Assert.AreEqual(23, count); // Check the contents // 1st block is at 0 Assert.AreEqual((byte)0x9e, b0[0]); Assert.AreEqual((byte)0x75, b0[1]); Assert.AreEqual((byte)0x97, b0[2]); Assert.AreEqual((byte)0xf6, b0[3]); // 2nd block is at 1 Assert.AreEqual((byte)0x86, b1[0]); Assert.AreEqual((byte)0x09, b1[1]); Assert.AreEqual((byte)0x22, b1[2]); Assert.AreEqual((byte)0xfb, b1[3]); // last block is at 89 Assert.AreEqual((byte)0xfe, b22[0]); Assert.AreEqual((byte)0xff, b22[1]); Assert.AreEqual((byte)0x00, b22[2]); Assert.AreEqual((byte)0x00, b22[3]); Assert.AreEqual((byte)0x05, b22[4]); Assert.AreEqual((byte)0x01, b22[5]); Assert.AreEqual((byte)0x02, b22[6]); Assert.AreEqual((byte)0x00, b22[7]); }
public EncryptionInfo(NPOIFSFileSystem fs) : this(fs.Root) { }
public void TestReplaceStream() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); byte[] data = new byte[512]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i % 256); } // 98 is actually the last block in a two block stream... NPOIFSStream stream = new NPOIFSStream(fs, 98); stream.UpdateContents(data); // Check the reading of blocks IEnumerator<ByteBuffer> it = stream.GetBlockIterator(); Assert.AreEqual(true, it.MoveNext()); // it.MoveNext(); ByteBuffer b = it.Current; Assert.AreEqual(false, it.MoveNext()); // Now check the contents data = new byte[512]; b.Read(data); for (int i = 0; i < data.Length; i++) { byte exp = (byte)(i % 256); Assert.AreEqual(exp, data[i]); } }
public void TestWriteStream4096() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize4096.zvi")); // 0 -> 1 -> 2 -> end Assert.AreEqual(1, fs.GetNextBlock(0)); Assert.AreEqual(2, fs.GetNextBlock(1)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(2)); Assert.AreEqual(4, fs.GetNextBlock(3)); // First free one is at 15 Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(14)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(15)); // Write a 5 block file byte[] data = new byte[4096 * 5]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i % 256); } NPOIFSStream stream = new NPOIFSStream(fs, 0); stream.UpdateContents(data); // Check it Assert.AreEqual(1, fs.GetNextBlock(0)); Assert.AreEqual(2, fs.GetNextBlock(1)); Assert.AreEqual(15, fs.GetNextBlock(2)); // Jumps Assert.AreEqual(4, fs.GetNextBlock(3)); // Next stream Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(14)); Assert.AreEqual(16, fs.GetNextBlock(15)); // Continues Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(16)); // Ends Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(17)); // Free // Check the contents too IEnumerator<ByteBuffer> it = stream.GetBlockIterator(); int count = 0; while (it.MoveNext()) { ByteBuffer b = it.Current; data = new byte[512]; // b.get(data); // Array.Copy(b, 0, data, 0, b.Length); b.Read(data); for (int i = 0; i < data.Length; i++) { byte exp = (byte)(i % 256); Assert.AreEqual(exp, data[i]); } count++; } Assert.AreEqual(5, count); }
public void TestWriteMiniStreams() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); NPOIFSMiniStore ministore = fs.GetMiniStore(); NPOIFSStream stream = new NPOIFSStream(ministore, 178); // 178 -> 179 -> 180 -> end Assert.AreEqual(179, ministore.GetNextBlock(178)); Assert.AreEqual(180, ministore.GetNextBlock(179)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(180)); // Try writing 3 full blocks worth byte[] data = new byte[64 * 3]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)i; } stream = new NPOIFSStream(ministore, 178); stream.UpdateContents(data); // Check Assert.AreEqual(179, ministore.GetNextBlock(178)); Assert.AreEqual(180, ministore.GetNextBlock(179)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(180)); stream = new NPOIFSStream(ministore, 178); IEnumerator<ByteBuffer> it = stream.GetBlockIterator(); it.MoveNext(); ByteBuffer b178 = it.Current; it.MoveNext(); ByteBuffer b179 = it.Current; it.MoveNext(); ByteBuffer b180 = it.Current; Assert.AreEqual(false, it.MoveNext()); Assert.AreEqual((byte)0x00, b178.Read()); Assert.AreEqual((byte)0x01, b178.Read()); Assert.AreEqual((byte)0x40, b179.Read()); Assert.AreEqual((byte)0x41, b179.Read()); Assert.AreEqual((byte)0x80, b180.Read()); Assert.AreEqual((byte)0x81, b180.Read()); // Try writing just into 3 blocks worth data = new byte[64 * 2 + 12]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i + 4); } stream = new NPOIFSStream(ministore, 178); stream.UpdateContents(data); // Check Assert.AreEqual(179, ministore.GetNextBlock(178)); Assert.AreEqual(180, ministore.GetNextBlock(179)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(180)); stream = new NPOIFSStream(ministore, 178); it = stream.GetBlockIterator(); it.MoveNext(); b178 = it.Current; it.MoveNext(); b179 = it.Current; it.MoveNext(); b180 = it.Current; Assert.AreEqual(false, it.MoveNext()); Assert.AreEqual((byte)0x04, b178.Read()); Assert.AreEqual((byte)0x05, b178.Read()); Assert.AreEqual((byte)0x44, b179.Read()); Assert.AreEqual((byte)0x45, b179.Read()); Assert.AreEqual((byte)0x84, b180.Read()); Assert.AreEqual((byte)0x85, b180.Read()); // Try writing 1, should truncate data = new byte[12]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i + 9); } stream = new NPOIFSStream(ministore, 178); stream.UpdateContents(data); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(178)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(179)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(180)); stream = new NPOIFSStream(ministore, 178); it = stream.GetBlockIterator(); it.MoveNext(); b178 = it.Current; Assert.AreEqual(false, it.MoveNext()); Assert.AreEqual((byte)0x09, b178[0]); Assert.AreEqual((byte)0x0a, b178[1]); // Try writing 5, should extend Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(178)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(179)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(180)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(181)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(182)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(183)); data = new byte[64 * 4 + 12]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i + 3); } stream = new NPOIFSStream(ministore, 178); stream.UpdateContents(data); Assert.AreEqual(179, ministore.GetNextBlock(178)); Assert.AreEqual(180, ministore.GetNextBlock(179)); Assert.AreEqual(181, ministore.GetNextBlock(180)); Assert.AreEqual(182, ministore.GetNextBlock(181)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(182)); stream = new NPOIFSStream(ministore, 178); it = stream.GetBlockIterator(); it.MoveNext(); b178 = it.Current; it.MoveNext(); b179 = it.Current; it.MoveNext(); b180 = it.Current; it.MoveNext(); ByteBuffer b181 = it.Current; it.MoveNext(); ByteBuffer b182 = it.Current; Assert.AreEqual(false, it.MoveNext()); Assert.AreEqual((byte)0x03, b178[0]); Assert.AreEqual((byte)0x04, b178[1]); Assert.AreEqual((byte)0x43, b179[0]); Assert.AreEqual((byte)0x44, b179[1]); Assert.AreEqual((byte)0x83, b180[0]); Assert.AreEqual((byte)0x84, b180[1]); Assert.AreEqual((byte)0xc3, b181[0]); Assert.AreEqual((byte)0xc4, b181[1]); Assert.AreEqual((byte)0x03, b182[0]); Assert.AreEqual((byte)0x04, b182[1]); // Write lots, so it needs another big block ministore.GetBlockAt(183); try { ministore.GetBlockAt(184); Assert.Fail("Block 184 should be off the end of the list"); } // catch (ArgumentOutOfRangeException e) catch(Exception) { } data = new byte[64 * 6 + 12]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i + 1); } stream = new NPOIFSStream(ministore, 178); stream.UpdateContents(data); // Should have added 2 more blocks to the chain Assert.AreEqual(179, ministore.GetNextBlock(178)); Assert.AreEqual(180, ministore.GetNextBlock(179)); Assert.AreEqual(181, ministore.GetNextBlock(180)); Assert.AreEqual(182, ministore.GetNextBlock(181)); Assert.AreEqual(183, ministore.GetNextBlock(182)); Assert.AreEqual(184, ministore.GetNextBlock(183)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(184)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(185)); // Block 184 should exist ministore.GetBlockAt(183); ministore.GetBlockAt(184); ministore.GetBlockAt(185); // Check contents stream = new NPOIFSStream(ministore, 178); it = stream.GetBlockIterator(); it.MoveNext(); b178 = it.Current; it.MoveNext(); b179 = it.Current; it.MoveNext(); b180 = it.Current; it.MoveNext(); b181 = it.Current; it.MoveNext(); b182 = it.Current; it.MoveNext(); ByteBuffer b183 = it.Current; it.MoveNext(); ByteBuffer b184 = it.Current; Assert.AreEqual(false, it.MoveNext()); Assert.AreEqual((byte)0x01, b178[0]); Assert.AreEqual((byte)0x02, b178[1]); Assert.AreEqual((byte)0x41, b179[0]); Assert.AreEqual((byte)0x42, b179[1]); Assert.AreEqual((byte)0x81, b180[0]); Assert.AreEqual((byte)0x82, b180[1]); Assert.AreEqual((byte)0xc1, b181[0]); Assert.AreEqual((byte)0xc2, b181[1]); Assert.AreEqual((byte)0x01, b182[0]); Assert.AreEqual((byte)0x02, b182[1]); Assert.AreEqual((byte)0x41, b183[0]); Assert.AreEqual((byte)0x42, b183[1]); Assert.AreEqual((byte)0x81, b184[0]); Assert.AreEqual((byte)0x82, b184[1]); }
/** * Checks if the supplied first 8 bytes of a stream / file * has a POIFS (OLE2) header. */ public static new bool HasPOIFSHeader(byte[] header8Bytes) { return(NPOIFSFileSystem.HasPOIFSHeader(header8Bytes)); }
public void TestReadStream4096() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize4096.zvi")); // 0 -> 1 -> 2 -> end NPOIFSStream stream = new NPOIFSStream(fs, 0); IEnumerator<ByteBuffer> i = stream.GetBlockIterator(); Assert.AreEqual(true, i.MoveNext()); // i.MoveNext(); ByteBuffer b0 = i.Current; Assert.AreEqual(true, i.MoveNext()); // i.MoveNext(); ByteBuffer b1 = i.Current; Assert.AreEqual(true, i.MoveNext()); // i.MoveNext(); ByteBuffer b2 = i.Current; Assert.AreEqual(false, i.MoveNext()); // Check the contents of the 1st block Assert.AreEqual((byte)0x9E, b0[0]); Assert.AreEqual((byte)0x75, b0[1]); Assert.AreEqual((byte)0x97, b0[2]); Assert.AreEqual((byte)0xF6, b0[3]); Assert.AreEqual((byte)0xFF, b0[4]); Assert.AreEqual((byte)0x21, b0[5]); Assert.AreEqual((byte)0xD2, b0[6]); Assert.AreEqual((byte)0x11, b0[7]); // Check the contents of the 2nd block Assert.AreEqual((byte)0x00, b1[0]); Assert.AreEqual((byte)0x00, b1[1]); Assert.AreEqual((byte)0x03, b1[2]); Assert.AreEqual((byte)0x00, b1[3]); Assert.AreEqual((byte)0x00, b1[4]); Assert.AreEqual((byte)0x00, b1[5]); Assert.AreEqual((byte)0x00, b1[6]); Assert.AreEqual((byte)0x00, b1[7]); // Check the contents of the 3rd block Assert.AreEqual((byte)0x6D, b2[0]); Assert.AreEqual((byte)0x00, b2[1]); Assert.AreEqual((byte)0x00, b2[2]); Assert.AreEqual((byte)0x00, b2[3]); Assert.AreEqual((byte)0x03, b2[4]); Assert.AreEqual((byte)0x00, b2[5]); Assert.AreEqual((byte)0x46, b2[6]); Assert.AreEqual((byte)0x00, b2[7]); }
public void TestWriteNewStream() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); // 100 is our first free one Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(100)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(101)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(102)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(103)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(104)); // Add a single block one byte[] data = new byte[512]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i % 256); } NPOIFSStream stream = new NPOIFSStream(fs); stream.UpdateContents(data); // Check it was allocated properly Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(100)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(101)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(102)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(103)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(104)); // And check the contents IEnumerator<ByteBuffer> it = stream.GetBlockIterator(); int count = 0; while (it.MoveNext()) { ByteBuffer b = it.Current; data = new byte[512]; //b.get(data); //Array.Copy(b, 0, data, 0, b.Length); b.Read(data); for (int i = 0; i < data.Length; i++) { byte exp = (byte)(i % 256); Assert.AreEqual(exp, data[i]); } count++; } Assert.AreEqual(1, count); // And a multi block one data = new byte[512 * 3]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i % 256); } stream = new NPOIFSStream(fs); stream.UpdateContents(data); // Check it was allocated properly Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(100)); Assert.AreEqual(102, fs.GetNextBlock(101)); Assert.AreEqual(103, fs.GetNextBlock(102)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(103)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(104)); // And check the contents it = stream.GetBlockIterator(); count = 0; while (it.MoveNext()) { ByteBuffer b = it.Current; data = new byte[512]; //b.get(data); // Array.Copy(b, 0, data, 0, b.Length); b.Read(data); for (int i = 0; i < data.Length; i++) { byte exp = (byte)(i % 256); Assert.AreEqual(exp, data[i]); } count++; } Assert.AreEqual(3, count); // Free it stream.free(); Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(100)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(101)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(102)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(103)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(104)); }
public void TestReplaceStreamWithMore() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); byte[] data = new byte[512 * 3]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i % 256); } // 97 -> 98 -> end Assert.AreEqual(98, fs.GetNextBlock(97)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(98)); // 100 is our first free one Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(100)); // Create a 2 block stream, will become a 3 block one NPOIFSStream stream = new NPOIFSStream(fs, 97); stream.UpdateContents(data); // 97 -> 98 -> 100 -> end Assert.AreEqual(98, fs.GetNextBlock(97)); Assert.AreEqual(100, fs.GetNextBlock(98)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(100)); // Check the reading of blocks IEnumerator<ByteBuffer> it = stream.GetBlockIterator(); int count = 0; while (it.MoveNext()) { ByteBuffer b = it.Current; data = new byte[512]; //b.get(data); //Array.Copy(b, 0, data, 0, b.Length); b.Read(data); for (int i = 0; i < data.Length; i++) { byte exp = (byte)(i % 256); Assert.AreEqual(exp, data[i]); } count++; } Assert.AreEqual(3, count); }
/// <summary> /// Checks that the supplied Stream(which MUST /// support mark and reset, or be a PushbackInputStream) /// has a POIFS (OLE2) header at the start of it. /// If your Streamdoes not support mark / reset, /// then wrap it in a PushBackInputStream, then be /// sure to always use that, and not the original! /// </summary> /// <param name="inp">An Streamwhich supports either mark/reset, or is a PushbackStream</param> /// <returns> /// <c>true</c> if [has POIFS header] [the specified inp]; otherwise, <c>false</c>. /// </returns> public static new bool HasPOIFSHeader(Stream inp) { return(NPOIFSFileSystem.HasPOIFSHeader(inp)); }
public HPSFPropertiesExtractor(NPOIFSFileSystem fs) : base(new HPSFPropertiesOnlyDocument(fs)) { }
public void TestWriteFailsOnLoop() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.GetFile("BlockSize512.zvi")); // Hack the FAT so that it goes 0->1->2->0 fs.SetNextBlock(0, 1); fs.SetNextBlock(1, 2); fs.SetNextBlock(2, 0); // Try to write a large amount, should fail on the write byte[] data = new byte[512 * 4]; NPOIFSStream stream = new NPOIFSStream(fs, 0); try { stream.UpdateContents(data); Assert.Fail("Loop should have been detected but wasn't!"); } catch (Exception) { } // Now reset, and try on a small bit // Should fail during the freeing set fs.SetNextBlock(0, 1); fs.SetNextBlock(1, 2); fs.SetNextBlock(2, 0); data = new byte[512]; stream = new NPOIFSStream(fs, 0); try { stream.UpdateContents(data); Assert.Fail("Loop should have been detected but wasn't!"); } catch (Exception) { } }
public void TestCreateBlockIfNeeded() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); NPOIFSMiniStore ministore = fs.GetMiniStore(); // 178 -> 179 -> 180, 181+ is free Assert.AreEqual(179, ministore.GetNextBlock(178)); Assert.AreEqual(180, ministore.GetNextBlock(179)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(180)); for (int i = 181; i < 256; i++) { Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(i)); } // However, the ministore data only covers blocks to 183 for (int i = 0; i <= 183; i++) { ministore.GetBlockAt(i); } try { ministore.GetBlockAt(184); Assert.Fail("No block at 184"); } catch (IndexOutOfRangeException) { } // The ministore itself is made up of 23 big blocks IEnumerator<ByteBuffer> it = new NPOIFSStream(fs, fs.Root.Property.StartBlock).GetBlockIterator(); int count = 0; while (it.MoveNext()) { count++; //it.MoveNext(); } Assert.AreEqual(23, count); // Ask it to get block 184 with creating, it will do ministore.CreateBlockIfNeeded(184); // The ministore should be one big block bigger now it = new NPOIFSStream(fs, fs.Root.Property.StartBlock).GetBlockIterator(); count = 0; while (it.MoveNext()) { count++; //it.MoveNext(); } Assert.AreEqual(24, count); // The mini block block counts now run to 191 for (int i = 0; i <= 191; i++) { ministore.GetBlockAt(i); } try { ministore.GetBlockAt(192); Assert.Fail("No block at 192"); } catch (IndexOutOfRangeException) { } // Now try writing through to 192, check that the SBAT and blocks are there byte[] data = new byte[15 * 64]; NPOIFSStream stream = new NPOIFSStream(ministore, 178); stream.UpdateContents(data); // Check now Assert.AreEqual(179, ministore.GetNextBlock(178)); Assert.AreEqual(180, ministore.GetNextBlock(179)); Assert.AreEqual(181, ministore.GetNextBlock(180)); Assert.AreEqual(182, ministore.GetNextBlock(181)); Assert.AreEqual(183, ministore.GetNextBlock(182)); Assert.AreEqual(184, ministore.GetNextBlock(183)); Assert.AreEqual(185, ministore.GetNextBlock(184)); Assert.AreEqual(186, ministore.GetNextBlock(185)); Assert.AreEqual(187, ministore.GetNextBlock(186)); Assert.AreEqual(188, ministore.GetNextBlock(187)); Assert.AreEqual(189, ministore.GetNextBlock(188)); Assert.AreEqual(190, ministore.GetNextBlock(189)); Assert.AreEqual(191, ministore.GetNextBlock(190)); Assert.AreEqual(192, ministore.GetNextBlock(191)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, ministore.GetNextBlock(192)); for (int i = 193; i < 256; i++) { Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, ministore.GetNextBlock(i)); } }
public void TestReadWriteNewStream() { NPOIFSFileSystem fs = new NPOIFSFileSystem(); NPOIFSStream stream = new NPOIFSStream(fs); // Check our filesystem has a BAT and the Properties Assert.AreEqual(2, fs.GetFreeBlock()); BATBlock bat = fs.GetBATBlockAndIndex(0).Block; Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, bat.GetValueAt(0)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, bat.GetValueAt(1)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, bat.GetValueAt(2)); // Check the stream as-is Assert.AreEqual(POIFSConstants.END_OF_CHAIN, stream.GetStartBlock()); try { stream.GetBlockIterator(); Assert.Fail("Shouldn't be able to get an iterator before writing"); } catch (Exception) { } // Write in two blocks byte[] data = new byte[512 + 20]; for (int i = 0; i < 512; i++) { data[i] = (byte)(i % 256); } for (int i = 512; i < data.Length; i++) { data[i] = (byte)(i % 256 + 100); } stream.UpdateContents(data); // Check now Assert.AreEqual(4, fs.GetFreeBlock()); bat = fs.GetBATBlockAndIndex(0).Block; Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, bat.GetValueAt(0)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, bat.GetValueAt(1)); Assert.AreEqual(3, bat.GetValueAt(2)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, bat.GetValueAt(3)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, bat.GetValueAt(4)); IEnumerator<ByteBuffer> it = stream.GetBlockIterator(); Assert.AreEqual(true, it.MoveNext()); ByteBuffer b = it.Current; byte[] read = new byte[512]; //b.get(read); // Array.Copy(b, 0, read, 0, b.Length); b.Read(read); for (int i = 0; i < read.Length; i++) { //Assert.AreEqual("Wrong value at " + i, data[i], read[i]); Assert.AreEqual(data[i], read[i], "Wrong value at " + i); } Assert.AreEqual(true, it.MoveNext()); b = it.Current; read = new byte[512]; //b.get(read); //Array.Copy(b, 0, read, 0, b.Length); b.Read(read); for (int i = 0; i < 20; i++) { Assert.AreEqual(data[i + 512], read[i]); } for (int i = 20; i < read.Length; i++) { Assert.AreEqual(0, read[i]); } Assert.AreEqual(false, it.MoveNext()); }
public void TestWriteWorkbookFromNPOIFS() { //throw new NotImplementedException("class NPOIFSFileSystem is not implemented"); Stream is1 = HSSFTestDataSamples.OpenSampleFileStream("WithEmbeddedObjects.xls"); NPOIFSFileSystem fs = new NPOIFSFileSystem(is1); // Start as NPOIFS HSSFWorkbook wb = new HSSFWorkbook(fs.Root, true); Assert.AreEqual(3, wb.NumberOfSheets); Assert.AreEqual("Root xls", wb.GetSheetAt(0).GetRow(0).GetCell(0).StringCellValue); // Will switch to POIFS wb = HSSFTestDataSamples.WriteOutAndReadBack(wb); Assert.AreEqual(3, wb.NumberOfSheets); Assert.AreEqual("Root xls", wb.GetSheetAt(0).GetRow(0).GetCell(0).StringCellValue); fs.Close(); }
/** * 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(NPOIFSFileSystem source, NPOIFSFileSystem target) { CopyNodes(source.Root, target.Root); }
public FilterInputStream1(InputStream input, NPOIFSFileSystem fs) : base(input) { this.fs = fs; }
public void TestReadMiniStreams() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); NPOIFSMiniStore ministore = fs.GetMiniStore(); // 178 -> 179 -> 180 -> end NPOIFSStream stream = new NPOIFSStream(ministore, 178); IEnumerator<ByteBuffer> i = stream.GetBlockIterator(); Assert.AreEqual(true, i.MoveNext()); // Assert.AreEqual(true, i.MoveNext()); // Assert.AreEqual(true, i.MoveNext()); // i.MoveNext(); ByteBuffer b178 = i.Current; Assert.AreEqual(true, i.MoveNext()); // Assert.AreEqual(true, i.MoveNext()); // i.MoveNext(); ByteBuffer b179 = i.Current; Assert.AreEqual(true, i.MoveNext()); // i.MoveNext(); ByteBuffer b180 = i.Current; Assert.AreEqual(false, i.MoveNext()); // Assert.AreEqual(false, i.MoveNext()); // Assert.AreEqual(false, i.MoveNext()); // Check the contents of the 1st block Assert.AreEqual((byte)0xfe, b178[0]); Assert.AreEqual((byte)0xff, b178[1]); Assert.AreEqual((byte)0x00, b178[2]); Assert.AreEqual((byte)0x00, b178[3]); Assert.AreEqual((byte)0x05, b178[4]); Assert.AreEqual((byte)0x01, b178[5]); Assert.AreEqual((byte)0x02, b178[6]); Assert.AreEqual((byte)0x00, b178[7]); // And the 2nd Assert.AreEqual((byte)0x6c, b179[0]); Assert.AreEqual((byte)0x00, b179[1]); Assert.AreEqual((byte)0x00, b179[2]); Assert.AreEqual((byte)0x00, b179[3]); Assert.AreEqual((byte)0x28, b179[4]); Assert.AreEqual((byte)0x00, b179[5]); Assert.AreEqual((byte)0x00, b179[6]); Assert.AreEqual((byte)0x00, b179[7]); // And the 3rd Assert.AreEqual((byte)0x30, b180[0]); Assert.AreEqual((byte)0x00, b180[1]); Assert.AreEqual((byte)0x00, b180[2]); Assert.AreEqual((byte)0x00, b180[3]); Assert.AreEqual((byte)0x00, b180[4]); Assert.AreEqual((byte)0x00, b180[5]); Assert.AreEqual((byte)0x00, b180[6]); Assert.AreEqual((byte)0x80, b180[7]); }
public void TestReplaceStreamWithLess() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); byte[] data = new byte[512]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i % 256); } // 97 -> 98 -> end Assert.AreEqual(98, fs.GetNextBlock(97)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(98)); // Create a 2 block stream, will become a 1 block one NPOIFSStream stream = new NPOIFSStream(fs, 97); stream.UpdateContents(data); // 97 should now be the end, and 98 free Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(97)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(98)); // Check the reading of blocks IEnumerator<ByteBuffer> it = stream.GetBlockIterator(); Assert.AreEqual(true, it.MoveNext()); ByteBuffer b = it.Current; Assert.AreEqual(false, it.MoveNext()); // Now check the contents data = new byte[512]; // b.get(data); //for (int i = 0; i < b.Length; i++) // data[i] = b[i]; //Array.Copy(b, 0, data, 0, b.Length); b.Read(data); for (int i = 0; i < data.Length; i++) { byte exp = (byte)(i % 256); Assert.AreEqual(exp, data[i]); } }
public void TestWriteNewStreamExtraFATs() { NPOIFSFileSystem fs = new NPOIFSFileSystem(_inst.OpenResourceAsStream("BlockSize512.zvi")); // Allocate almost all the blocks Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(99)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(100)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(127)); for (int i = 100; i < 127; i++) { fs.SetNextBlock(i, POIFSConstants.END_OF_CHAIN); } Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(127)); Assert.AreEqual(true, fs.GetBATBlockAndIndex(0).Block.HasFreeSectors); // Write a 3 block stream byte[] data = new byte[512 * 3]; for (int i = 0; i < data.Length; i++) { data[i] = (byte)(i % 256); } NPOIFSStream stream = new NPOIFSStream(fs); stream.UpdateContents(data); // Check we got another BAT Assert.AreEqual(false, fs.GetBATBlockAndIndex(0).Block.HasFreeSectors); Assert.AreEqual(true, fs.GetBATBlockAndIndex(128).Block.HasFreeSectors); // the BAT will be in the first spot of the new block Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(126)); Assert.AreEqual(129, fs.GetNextBlock(127)); Assert.AreEqual(POIFSConstants.FAT_SECTOR_BLOCK, fs.GetNextBlock(128)); Assert.AreEqual(130, fs.GetNextBlock(129)); Assert.AreEqual(POIFSConstants.END_OF_CHAIN, fs.GetNextBlock(130)); Assert.AreEqual(POIFSConstants.UNUSED_BLOCK, fs.GetNextBlock(131)); }