Ejemplo n.º 1
0
        public void TestShortConstructor()
        {
            // Get the logger to be used
            DummyPOILogger logger = (DummyPOILogger)POILogFactory.GetLogger(
                typeof(RawDataBlock)
                );

            logger.Reset(); // the logger may have been used before
            Assert.AreEqual(0, logger.logged.Count);

            // Test for various short sizes
            for (int k = 2049; k < 2560; k++)
            {
                byte[] data = new byte[k];

                for (int j = 0; j < k; j++)
                {
                    data[j] = (byte)j;
                }

                // Check we logged the error
                logger.Reset();
                new RawDataBlockList(new MemoryStream(data), POIFSConstants.SMALLER_BIG_BLOCK_SIZE_DETAILS);
                Assert.AreEqual(1, logger.logged.Count);
            }
        }
Ejemplo n.º 2
0
        public void TestVariousLogTypes()
        {
            //NKB Testing only that logging classes use gives no exception
            //    Since logging can be disabled, no checking of logging
            //    output is done.

            POILogger log = POILogFactory.GetLogger("foo");

            log.Log(POILogger.WARN, "Test = ", 1);
        }
Ejemplo n.º 3
0
        public void TestShortConstructor()
        {
            //// Get the logger to be used
            DummyPOILogger logger = (DummyPOILogger)POILogFactory.GetLogger(typeof(RawDataBlock));

            logger.Reset(); // the logger may have been used before
            Assert.AreEqual(0, logger.logged.Count);

            // Test for various data sizes
            for (int k = 1; k <= 512; k++)
            {
                byte[] data = new byte[k];

                for (int j = 0; j < k; j++)
                {
                    data[j] = (byte)j;
                }
                RawDataBlock block = null;

                logger.Reset();
                Assert.AreEqual(0, logger.logged.Count);

                // Have it created
                block = new RawDataBlock(new MemoryStream(data));
                Assert.IsNotNull(block);

                // Check for the warning Is there for <512
                if (k < 512)
                {
                    Assert.AreEqual(
                        1, logger.logged.Count, "Warning on " + k + " byte short block"
                        );

                    // Build the expected warning message, and check
                    String bts = k + " byte";
                    if (k > 1)
                    {
                        bts += "s";
                    }

                    Assert.AreEqual(
                        (String)logger.logged[0],
                        "7 - Unable to read entire block; " + bts + " read before EOF; expected 512 bytes. Your document was either written by software that ignores the spec, or has been truncated!"
                        );
                }
                else
                {
                    Assert.AreEqual(0, logger.logged.Count);
                }
            }
        }
Ejemplo n.º 4
0
        public void TestVariousLogTypes()
        {
            //NKB Testing only that logging classes use gives no exception
            //    Since logging can be disabled, no checking of logging
            //    output is done.

            POILogger log = POILogFactory.GetLogger("foo");

            log.Log(POILogger.WARN, "Test = ", 1);
            log.LogFormatted(POILogger.ERROR, "Test param 1 = %, param 2 = %", "2", 3);
            log.LogFormatted(POILogger.ERROR, "Test param 1 = %, param 2 = %", new int[] { 4, 5 });
            log.LogFormatted(POILogger.ERROR,
                             "Test param 1 = %1.1, param 2 = %0.1", new double[] { 4, 5.23 });
        }
Ejemplo n.º 5
0
        public void TestSlowInputStream()
        {
            // Get the logger to be used
            DummyPOILogger logger = (DummyPOILogger)POILogFactory.GetLogger(typeof(RawDataBlock));

            logger.Reset(); // the logger may have been used before
            Assert.AreEqual(0, logger.logged.Count);

            // Test for various ok data sizes
            for (int k = 1; k < 512; k++)
            {
                byte[] data = new byte[512];
                for (int j = 0; j < data.Length; j++)
                {
                    data[j] = (byte)j;
                }

                // Shouldn't complain, as there Is enough data,
                //  even if it dribbles through
                RawDataBlock block =
                    new RawDataBlock(new SlowInputStream(data, 512));   //k is changed to 512
                Assert.IsFalse(block.EOF);
            }

            // But if there wasn't enough data available, will
            //  complain
            for (int k = 1; k < 512; k++)
            {
                byte[] data = new byte[511];
                for (int j = 0; j < data.Length; j++)
                {
                    data[j] = (byte)j;
                }

                logger.Reset();
                Assert.AreEqual(0, logger.logged.Count);

                // Should complain, as there Isn't enough data
                RawDataBlock block =
                    new RawDataBlock(new SlowInputStream(data, k));
                Assert.IsNotNull(block);
                Assert.AreEqual(
                    1, logger.logged.Count, "Warning on " + k + " byte short block"
                    );
            }
        }
Ejemplo n.º 6
0
        public void TestLog()
        {
            //NKB Testing only that logging classes use gives no exception
            //    Since logging can be disabled, no checking of logging
            //    output is done.

            POILogger l1 = POILogFactory.GetLogger("org.apache.poi.hssf.test");
            POILogger l2 = POILogFactory.GetLogger("org.apache.poi.hdf.test");

            l1.Log(POILogger.FATAL, "testing cat org.apache.poi.hssf.*:FATAL");
            l1.Log(POILogger.ERROR, "testing cat org.apache.poi.hssf.*:ERROR");
            l1.Log(POILogger.WARN, "testing cat org.apache.poi.hssf.*:WARN");
            l1.Log(POILogger.INFO, "testing cat org.apache.poi.hssf.*:INFO");
            l1.Log(POILogger.DEBUG, "testing cat org.apache.poi.hssf.*:DEBUG");

            l2.Log(POILogger.FATAL, "testing cat org.apache.poi.hdf.*:FATAL");
            l2.Log(POILogger.ERROR, "testing cat org.apache.poi.hdf.*:ERROR");
            l2.Log(POILogger.WARN, "testing cat org.apache.poi.hdf.*:WARN");
            l2.Log(POILogger.INFO, "testing cat org.apache.poi.hdf.*:INFO");
            l2.Log(POILogger.DEBUG, "testing cat org.apache.poi.hdf.*:DEBUG");
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Reads the dictionary.
        /// </summary>
        /// <param name="src">The byte array containing the bytes making out the dictionary.</param>
        /// <param name="offset">At this offset within src the dictionary starts.</param>
        /// <param name="Length">The dictionary Contains at most this many bytes.</param>
        /// <param name="codepage">The codepage of the string values.</param>
        /// <returns>The dictonary</returns>
        protected IDictionary ReadDictionary(byte[] src, long offset,
                                             int Length, int codepage)
        {
            /* Check whether "offset" points into the "src" array". */
            if (offset < 0 || offset > src.Length)
            {
                throw new HPSFRuntimeException
                          ("Illegal offset " + offset + " while HPSF stream Contains " +
                          Length + " bytes.");
            }
            int o = (int)offset;

            /*
             * Read the number of dictionary entries.
             */
            long nrEntries = LittleEndian.GetUInt(src, o);

            o += LittleEndianConsts.INT_SIZE;

            Hashtable m = new Hashtable((int)nrEntries, (float)1.0);

            try
            {
                for (int i = 0; i < nrEntries; i++)
                {
                    /* The key. */
                    long id = LittleEndian.GetUInt(src, o);
                    o += LittleEndianConsts.INT_SIZE;

                    /* The value (a string). The Length is the either the
                     * number of (two-byte) characters if the character Set is Unicode
                     * or the number of bytes if the character Set is not Unicode.
                     * The Length includes terminating 0x00 bytes which we have To strip
                     * off To Create a Java string. */
                    long sLength = LittleEndian.GetUInt(src, o);
                    o += LittleEndianConsts.INT_SIZE;

                    /* Read the string. */
                    StringBuilder b = new StringBuilder();
                    switch (codepage)
                    {
                    case -1:
                    {
                        /* Without a codepage the Length is equal To the number of
                         * bytes. */
                        b.Append(Encoding.UTF8.GetString(src, o, (int)sLength));
                        break;
                    }

                    case (int)Constants.CP_UNICODE:
                    {
                        /* The Length is the number of characters, i.e. the number
                         * of bytes is twice the number of the characters. */
                        int    nrBytes = (int)(sLength * 2);
                        byte[] h       = new byte[nrBytes];
                        for (int i2 = 0; i2 < nrBytes; i2 += 2)
                        {
                            h[i2]     = src[o + i2 + 1];
                            h[i2 + 1] = src[o + i2];
                        }
                        b.Append(Encoding.GetEncoding(codepage).GetString(h, 0, nrBytes));
                        break;
                    }

                    default:
                    {
                        /* For encodings other than Unicode the Length is the number
                         * of bytes. */
                        b.Append(Encoding.GetEncoding(codepage).GetString(src, o, (int)sLength));
                        break;
                    }
                    }

                    /* Strip 0x00 characters from the end of the string: */
                    while (b.Length > 0 && b[b.Length - 1] == 0x00)
                    {
                        b.Length = b.Length - 1;
                    }
                    if (codepage == (int)Constants.CP_UNICODE)
                    {
                        if (sLength % 2 == 1)
                        {
                            sLength++;
                        }
                        o += (int)(sLength + sLength);
                    }
                    else
                    {
                        o += (int)sLength;
                    }
                    m[id] = b.ToString();
                }
            }
            catch (Exception ex)
            {
                POILogger l = POILogFactory.GetLogger(typeof(Property));
                l.Log(POILogger.WARN,
                      "The property Set's dictionary Contains bogus data. "
                      + "All dictionary entries starting with the one with ID "
                      + id + " will be ignored.", ex);
            }
            return(m);
        }