示例#1
0
        public void PhpSerialization3()
        {
            XDoc doc = new XDoc("test");

            doc.Value("<tag>ö</tag>");
            Encoding     encoding = Encoding.GetEncoding("ISO-8859-1");
            MemoryStream stream   = new MemoryStream();

            PhpUtil.WritePhp(doc, stream, encoding);
            byte[] text = stream.ToArray();
            Assert.IsTrue(ArrayUtil.Compare(encoding.GetBytes("a:1:{s:4:\"test\";s:12:\"<tag>ö</tag>\";}"), text) == 0);
        }
示例#2
0
        public void XDocFactory_parse_XHTML_with_entity_codes()
        {
            string xhtml = "<html><body>&Omega; &alefsym; &Yuml; &euro; &copy; &oslash; &nbsp;</body></html>";
            XDoc   doc   = XDocFactory.From(xhtml, MimeType.HTML);

            Assert.AreNotEqual(null, doc, "could not load XHTML document");

            // check if entities were converted
            string text = doc["body"].AsText;

            byte[] values = new byte[] { 206, 169, 32, 226, 132, 181, 32, 197, 184, 32, 226, 130, 172, 32, 194, 169, 32, 195, 184, 32, 194, 160 };
            Assert.IsTrue(ArrayUtil.Compare(values, Encoding.UTF8.GetBytes(text)) == 0, "incorrect entity encoding");
        }
示例#3
0
        public void Can_copy_stream_to_file()
        {
            var bytes    = GetBytes(1000);
            var stream   = new MemoryStream(bytes);
            var tempFile = Path.GetTempFileName();

            try {
                stream.CopyToFile(tempFile, stream.Length);
                var fileBytes = File.ReadAllBytes(tempFile);
                Assert.AreEqual(0, ArrayUtil.Compare(bytes, fileBytes));
            } finally {
                File.Delete(tempFile);
            }
        }
        private void MapRecords(QueueFileInfo queueFileInfo)
        {
            if (queueFileInfo.Stream.Length == 0)
            {
                return;
            }
            queueFileInfo.Stream.Position = 0;
            var header = new byte[RecordMarker.Length];

            while (true)
            {
                var position     = queueFileInfo.Stream.Position;
                var missedHeader = false;
                int read;
                var isDeleted = false;
                while (true)
                {
                    read = queueFileInfo.Stream.Read(header, 0, header.Length);
                    if (read != header.Length)
                    {
                        // end of file? WTF? ok, bail
                        _log.Warn("reached end of file trying to read the next record marker");
                        return;
                    }
                    if (ArrayUtil.Compare(header, RecordMarker) == 0)
                    {
                        break;
                    }
                    if (ArrayUtil.Compare(header, DeletedMarker) == 0)
                    {
                        isDeleted = true;
                        break;
                    }
                    queueFileInfo.Stream.Position = ++position;
                    missedHeader = true;
                }
                if (missedHeader)
                {
                    _log.Warn("missed expected header and skipped corrupt data");
                }
                var lengthBytes = new byte[LENGTH_SIZE];
                read = queueFileInfo.Stream.Read(lengthBytes, 0, LENGTH_SIZE);
                if (read < LENGTH_SIZE)
                {
                    // end of file? WTF? ok, bail
                    _log.Warn("reached end of file trying to read the number of bytes in the next record, skipping record");
                    queueFileInfo.Stream.Seek(0, SeekOrigin.Begin);
                    return;
                }
                var length = BitConverter.ToInt32(lengthBytes, 0);
                if (length <= 0)
                {
                    _log.Warn("illegal record length, must be in corrupted record, skipping record");
                    queueFileInfo.Stream.Position = ++position;
                    continue;
                }
                if (!isDeleted)
                {
                    position = queueFileInfo.Stream.Position - HEADER_SIZE;
                    AddHandle(queueFileInfo.Id, position, length);
                }
                if (queueFileInfo.Stream.Seek(length, SeekOrigin.Current) == queueFileInfo.Stream.Length)
                {
                    break;
                }
            }
            queueFileInfo.Stream.Seek(0, SeekOrigin.Begin);
        }