Ejemplo n.º 1
0
        /**
         * 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");
            }
        }
Ejemplo n.º 2
0
        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;
        }
Ejemplo n.º 3
0
        /**
         * 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;
        }
Ejemplo n.º 4
0
        /**
         * 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();
                }
            }
        }
Ejemplo n.º 5
0
        /**
     * 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();
            }
        }
Ejemplo n.º 6
0
 /**
  * <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();
     }
 }
Ejemplo n.º 7
0
        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());
            }
        }
Ejemplo n.º 8
0
        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
                }
            }
        }
Ejemplo n.º 9
0
        /**
         * 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;
        }
Ejemplo n.º 10
0
 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;
     }
 }
Ejemplo n.º 11
0
        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);
                    }
                }
            }
        }
Ejemplo n.º 12
0
        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());
        }
Ejemplo n.º 13
0
        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);
        }
Ejemplo n.º 14
0
        /**
         * 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();
            }
        }
Ejemplo n.º 15
0
        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");
        }
Ejemplo n.º 16
0
        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);
            }
        }
Ejemplo n.º 17
0
        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
            }
        }
Ejemplo n.º 18
0
 /**
  * Create an InputStream from the specified Document
  * 
  * @param document the Document to be read
  */
 public DocumentInputStream(NPOIFSDocument document)
 {
     delegate1 = new NDocumentInputStream(document);
 }
Ejemplo n.º 19
0
        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());
            }
        }
Ejemplo n.º 20
0
        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;
        }
Ejemplo n.º 21
0
        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
                }
            }
        }
Ejemplo n.º 22
0
 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();
             }
         }
     }
 }
Ejemplo n.º 23
0
        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
                }
            }
        }