public void ItDoesLookahead(string input, int count, bool eHas, char eChar) { var result = new LookAheadStream <char>(input).LookAhead(count); Assert.AreEqual(eHas, result.HasCharactersUpTo); Assert.AreEqual(eChar, result.Value); }
private void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { if (_inputStream != null) { _inputStream.Dispose(); _inputStream = null; } if (_hmacBufferStream != null) { _hmacBufferStream.Dispose(); _hmacBufferStream = null; } if (_hmacStream != null) { _hmacStream.Dispose(); _hmacStream = null; } _disposed = true; } }
public void ItEnumeratesAfterLookAhead(string @in, int lookTo) { var lookAhead = new LookAheadStream<char>(@in); lookAhead.LookAhead(lookTo); var enumeratedLookAhead = lookAhead.ToArray(); Assert.That(enumeratedLookAhead.SequenceEqual(@in)); }
private void DisposeInternal() { if (_outStream != null) { if (!_hasFinalFlushed) { FinalFlush(); } _outStream.Dispose(); _outStream = null; } if (_inStream != null) { _inStream.Dispose(); _inStream = null; } if (_transform != null) { _transform.Dispose(); _transform = null; } }
public override CryptoStreamBase Initialize(Stream stream, ICryptoTransform transform, CryptoStreamMode mode) { if (stream == null) { throw new ArgumentNullException("stream"); } if (transform == null) { throw new ArgumentNullException("transform"); } if (transform.InputBlockSize != transform.OutputBlockSize) { throw new ArgumentException("The transform must have the same input and output block size.", "transform"); } _transform = transform; if (mode == CryptoStreamMode.Read) { _inStream = new LookAheadStream(stream); } else { _outStream = stream; } _blockBuffer = new ByteBuffer(new byte[_transform.InputBlockSize]); _blockBuffer.AvailableForRead = 0; return(this); }
/// <summary> /// Implement an AxCryptReader based on a Stream. /// </summary> /// <param name="inputStream">The stream. Will be disposed when this instance is disposed.</param> protected AxCryptReaderBase(LookAheadStream inputStream) : this() { if (inputStream == null) { throw new ArgumentNullException("inputStream"); } InputStream = inputStream; }
public AxCryptReader CreateReader(LookAheadStream inputStream) { IList <HeaderBlock> headers = LoadUnversionedHeaders(inputStream); AxCryptReader reader = CreateVersionedReader(inputStream, headers); reader.Reinterpret(headers, HeaderBlocks); return(reader); }
public void ItEnumeratesAfterLookAhead(string @in, int lookTo) { var lookAhead = new LookAheadStream <char>(@in); lookAhead.LookAhead(lookTo); var enumeratedLookAhead = lookAhead.ToArray(); Assert.That(enumeratedLookAhead.SequenceEqual(@in)); }
public void ATotallyCrazyLookAheadDoesNotHurtTraversal(string @in) { var rand = new Random(); var lookAhead = new LookAheadStream<char>(@in); foreach (char t in @in) { lookAhead.LookAhead(rand.Next(10)); Assert.IsTrue(lookAhead.MoveNext()); Assert.AreEqual(t, lookAhead.Current); } }
public void ATotallyCrazyLookAheadDoesNotHurtTraversal(string @in) { var rand = new Random(); var lookAhead = new LookAheadStream <char>(@in); foreach (char t in @in) { lookAhead.LookAhead(rand.Next(10)); Assert.IsTrue(lookAhead.MoveNext()); Assert.AreEqual(t, lookAhead.Current); } }
/// <summary> /// Implement an AxCryptReader based on a Stream. /// </summary> /// <param name="inputStream">The stream. Will be disposed when this instance is disposed.</param> public AxCryptStreamReader(Stream inputStream) { if (inputStream == null) { throw new ArgumentNullException("inputStream"); } LookAheadStream lookAheadStream = inputStream as LookAheadStream; if (lookAheadStream == null) { lookAheadStream = new LookAheadStream(inputStream); } SetInputStream(lookAheadStream); }
public void ItDiesOnIllegalStatements(string code) { var llstream = new LookAheadStream<Token>(new Lexer(code.ToStream()).Lex()); var parser = new DaisyParser(llstream); try { parser.Parse(); } catch (Exception) { //throw; return; } Assert.Fail("Expected " + code + " to not parse"); }
public void ItParsesLanguages(string code, string expectedTree) { var llstream = new LookAheadStream <Token>(new Lexer(code.ToStream()).Lex()); var parser = new DaisyParser(llstream); var tree = parser.Parse(); Assert.IsNotNull(tree); var actualTree = DaisyAstPrinter.Print(tree.Root); if (expectedTree != actualTree) { Console.WriteLine(expectedTree); Console.WriteLine("----------------"); Console.WriteLine(actualTree); } Assert.AreEqual(expectedTree, actualTree); }
protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { if (_inputStream != null) { _inputStream.Dispose(); _inputStream = null; } } _disposed = true; }
private static AxCryptReader CreateVersionedReader(LookAheadStream inputStream, IList <HeaderBlock> headers) { AxCryptReader reader; VersionHeaderBlock versionHeaderBlock = FindHeaderBlock <VersionHeaderBlock>(headers); switch (versionHeaderBlock.FileVersionMajor) { case 1: case 2: case 3: reader = new V1AxCryptReader(inputStream); break; case 4: reader = new V2AxCryptReader(inputStream); break; default: throw new FileFormatException("Too new file format. You need a more recent version."); } return(reader); }
public MineDefineParser(IEnumerable<LexToken> tokens) { _tokens = new LookAheadStream<LexToken>(tokens); }
public void ItParsesLanguages(string code, string expectedTree) { var llstream = new LookAheadStream<Token>(new Lexer(code.ToStream()).Lex()); var parser = new DaisyParser(llstream); var tree = parser.Parse(); Assert.IsNotNull(tree); var actualTree = DaisyAstPrinter.Print(tree.Root); if(expectedTree != actualTree) { Console.WriteLine(expectedTree); Console.WriteLine("----------------"); Console.WriteLine(actualTree); } Assert.AreEqual(expectedTree, actualTree); }
public void ItDoesLookahead(string input, int count, bool eHas, char eChar) { var result = new LookAheadStream<char>(input).LookAhead(count); Assert.AreEqual(eHas, result.HasCharactersUpTo); Assert.AreEqual(eChar, result.Value); }
private static IList <HeaderBlock> LoadUnversionedHeaders(LookAheadStream inputStream) { UnversionedAxCryptReader vxReader = new UnversionedAxCryptReader(inputStream); return(LoadFromReader(vxReader)); }
protected void SetInputStream(LookAheadStream inputStream) { _inputStream = inputStream; }
public FormatIntegrityChecker(Stream inputStream, string fileName) { _inputStream = new LookAheadStream(inputStream ?? throw new ArgumentNullException(nameof(inputStream), "inputStream")); _fileName = fileName ?? throw new ArgumentNullException(nameof(fileName), "fileName"); }
/// <summary> /// Initializes a new instance of the <see cref="UnversionedAxCryptReader"/> class. /// </summary> /// <param name="inputStream">The stream. Will NOT be disposed when this instance is disposed.</param> public UnversionedAxCryptReader(LookAheadStream inputStream) : base(inputStream) { }
public static void TestLookAheadStream() { Assert.Throws <ArgumentNullException>(() => { using (Stream stream = new LookAheadStream(null)) { } }, "Input stream cannot be null."); Assert.Throws <ArgumentException>(() => { using (Stream writeOnlyStream = new DeflateStream(new MemoryStream(), CompressionMode.Compress)) { using (Stream stream = new LookAheadStream(writeOnlyStream)) { } } }, "The input stream must support reading."); using (Stream inputStream = new MemoryStream()) { byte[] inData = Encoding.UTF8.GetBytes("0123456789"); inputStream.Write(inData, 0, inData.Length); inputStream.Position = 0; using (LookAheadStream lookAheadStream = new LookAheadStream(inputStream)) { Assert.That(lookAheadStream.CanRead, Is.True, "The stream always supports reading."); Assert.That(lookAheadStream.CanSeek, Is.False, "The stream does not support seeking."); Assert.That(lookAheadStream.CanWrite, Is.False, "The stream does not support writing."); Assert.Throws <NotSupportedException>(() => { long length = lookAheadStream.Length; // Make FxCop not complain Object.Equals(length, null); }); Assert.Throws <NotSupportedException>(() => { long position = lookAheadStream.Position; // Make FxCop not complain Object.Equals(position, null); }); Assert.Throws <NotSupportedException>(() => { lookAheadStream.Position = 0; }); Assert.Throws <NotSupportedException>(() => { lookAheadStream.Seek(0, SeekOrigin.Begin); }); Assert.Throws <NotSupportedException>(() => { lookAheadStream.SetLength(0); }); Assert.Throws <NotSupportedException>(() => { lookAheadStream.Write(new byte[1], 0, 1); }); int count; byte[] buffer; lookAheadStream.Pushback(new byte[] { 0x99 }, 0, 1); buffer = new byte[1]; count = lookAheadStream.Read(buffer, 0, 1); Assert.That(count, Is.EqualTo(1), "One byte was read."); Assert.That(buffer[0], Is.EqualTo(0x99), "A byte with value 0x99 was pushed back."); buffer = new byte[5]; count = lookAheadStream.Read(buffer, 0, buffer.Length); Assert.That(count, Is.EqualTo(5), "Five bytes were read."); Assert.That(buffer, Is.EquivalentTo(new byte[] { 48, 49, 50, 51, 52 }), "The string '01234' was read."); lookAheadStream.Pushback(new byte[] { 52 }, 0, 1); lookAheadStream.Pushback(new byte[] { 51 }, 0, 1); lookAheadStream.Pushback(new byte[] { 48, 49, 50 }, 0, 3); // Nothing should happen, this is a pure dummy call. lookAheadStream.Flush(); buffer = new byte[10]; bool exactWasRead = lookAheadStream.ReadExact(buffer); Assert.That(exactWasRead, Is.True, "Ten bytes were read."); Assert.That(buffer, Is.EquivalentTo(new byte[] { 48, 49, 50, 51, 52, 53, 54, 55, 56, 57 }), "The string '0123456789' was read."); // This also implicitly tests double-dispose since we're in a using block lookAheadStream.Dispose(); Assert.Throws <ObjectDisposedException>(() => { buffer = new byte[3]; lookAheadStream.Read(buffer, 0, 3); }); Assert.Throws <ObjectDisposedException>(() => { buffer = new byte[5]; lookAheadStream.ReadExact(buffer); }); Assert.Throws <ObjectDisposedException>(() => { buffer = new byte[5]; lookAheadStream.Pushback(buffer, 0, buffer.Length); }); } } }
public DaisyParser(LookAheadStream<Token> tokenStream) { this.tokenStream = tokenStream; }
/// <summary> /// Instantiate an AxCryptReader from a stream. /// </summary> /// <param name="inputStream">The stream to read from, will be disposed when this instance is disposed.</param> /// <returns></returns> public V2AxCryptReader(LookAheadStream inputStream) : base(inputStream) { }
public AxCryptReaderForTest(LookAheadStream inputStream) : base(inputStream) { }
public static DaisyAst Parse(string code) { var llstream = new LookAheadStream<Token>(new Lexer(code.ToStream()).Lex()); var parser = new DaisyParser(llstream); return parser.Parse(); }
protected AxCryptReader(LookAheadStream inputStream) : base(inputStream) { }
public TestingAxCryptReader(LookAheadStream inputStream) : base(inputStream) { }
private static void ReadMultiPartFormData(Connection con, WebRequest request, string contentType, Stream bodyStream) { request.PostVars = new NameValueCollection(); int boundaryOffset = contentType.IndexOf("boundary="); if (boundaryOffset < 0) { return; } string boundary = contentType.Substring(boundaryOffset + 9); LookAheadStream lookAheadStream = new LookAheadStream(bodyStream, 200); // Read and discard the preamble. MultiPartMIMEStream multiPartStream = new MultiPartMIMEStream(lookAheadStream, "--" + boundary); for (; ;) { byte[] discardBuffer = new byte[100]; if (multiPartStream.Read(discardBuffer, 0, discardBuffer.Length) == 0) { break; } } multiPartStream.SkipBoundary(); // Read and save any following parts. for (; ;) { if (multiPartStream.LastPartRead || multiPartStream.TotalBytesRead == 0) { break; } multiPartStream = new MultiPartMIMEStream(lookAheadStream, "\r\n--" + boundary); bool connectionBroken; NameValueCollection headers = ReadAllHeaders(multiPartStream, out connectionBroken); if (connectionBroken) { con.ConnectionBroken = true; } using (MemoryStream memStream = new MemoryStream()) { using (BufferedStream partBody = new BufferedStream(memStream, 1024)) { multiPartStream.CopyTo(partBody, 1024); multiPartStream.SkipBoundary(); partBody.Flush(); partBody.Seek(0, SeekOrigin.Begin); string contentDisposition = headers.Get(HttpHeaders.ContentDisposition); if (contentDisposition != null) { // save uploaded files in data structures compatible with the way ASP.NET exposes them string[] parts = contentDisposition.Split(';'); bool formDataFound = false; string name = null; string filename = null; foreach (string part in parts) { string trimmedPart = part.Trim(); if (trimmedPart == "form-data") { formDataFound = true; } else if (trimmedPart.StartsWith("name=\"")) { name = trimmedPart.Substring(6, trimmedPart.Length - 7); } else if (trimmedPart.StartsWith("filename=\"")) { filename = trimmedPart.Substring(10, trimmedPart.Length - 11); } } if (!formDataFound) { throw new InvalidDataException(); } if (filename != null) { AddNameValuePair(request.PostVars, name, filename); partBody.Seek(0, SeekOrigin.Begin); string fileContentType = headers.Get(HttpHeaders.ContentType); if (string.IsNullOrEmpty(fileContentType)) { fileContentType = HttpHeaders.ContentType_TextPlain; } WebUploadedFile file = new WebUploadedFile(filename, partBody, partBody.Length, fileContentType); request.UploadedFiles.Add(name, file); } else { string value; bool ignoreConnectionBroken; Connection.ReadAsciiUntilEnd(partBody, out value, out ignoreConnectionBroken); AddNameValuePair(request.PostVars, name, value); } } } } } // Discard the epilogue for (; ;) { byte[] discardBuffer = new byte[100]; if (lookAheadStream.Read(discardBuffer, 0, discardBuffer.Length) == 0) { break; } } }