public void Constructor_ShouldSetTheBufferPropertyToACopyOfTheBufferParameterValue()
 {
     // ReSharper disable PossibleMultipleEnumeration
     byte[] bufferParameterValue = new byte[] {0, 1, 2, 3};
     IEnumerable<byte> bufferPropertyValue = new StreamWriteTransformingEventArgs(bufferParameterValue, 0, 0, Mock.Of<Encoding>()).Buffer;
     Assert.AreNotEqual(bufferParameterValue, bufferPropertyValue);
     Assert.AreEqual(bufferParameterValue.Length, bufferPropertyValue.Count());
     Assert.AreEqual(bufferParameterValue[0], bufferPropertyValue.ElementAt(0));
     Assert.AreEqual(bufferParameterValue[1], bufferPropertyValue.ElementAt(1));
     Assert.AreEqual(bufferParameterValue[2], bufferPropertyValue.ElementAt(2));
     Assert.AreEqual(bufferParameterValue[3], bufferPropertyValue.ElementAt(3));
     // ReSharper restore PossibleMultipleEnumeration
 }
        public override void Write(byte[] buffer, int offset, int count)
        {
            if(this.HasTransformWriteEvents)
            {
                StreamWriteTransformingEventArgs streamWriteTransformingEventArgs = new StreamWriteTransformingEventArgs(buffer, offset, count, this.Encoding);

                this.OnTransformWrite(streamWriteTransformingEventArgs);

                buffer = streamWriteTransformingEventArgs.TransformedBuffer.ToArray();
                offset = streamWriteTransformingEventArgs.TransformedOffset;
                count = streamWriteTransformingEventArgs.TransformedCount;
            }

            if(this.HasCaptureWriteEvents)
                this.OnCaptureWrite(new StreamWriteEventArgs(buffer, offset, count, this.Encoding));

            if(this.IsCaptured)
                this.CapturedStream.Write(buffer, offset, count);

            if(!this.HasTransformEvents)
                this.Stream.Write(buffer, offset, count);
        }
 private static void TransformWriteEventHandler(object sender, StreamWriteTransformingEventArgs e)
 {
 }
 public void TransformedOffset_Set_Test()
 {
     int transformedOffset = DateTime.Now.Millisecond;
     StreamWriteTransformingEventArgs streamWriteTransformingEventArgs = new StreamWriteTransformingEventArgs(new byte[0], 0, 0, Mock.Of<Encoding>())
     {
         TransformedOffset = transformedOffset
     };
     Assert.AreEqual(transformedOffset, streamWriteTransformingEventArgs.TransformedOffset);
 }
 public void TransformedOffset_Set_ShouldBeAbleToSetToLessThanZero()
 {
     int transformedOffset = (DateTime.Now.Millisecond + 1)*-1;
     StreamWriteTransformingEventArgs streamWriteTransformingEventArgs = new StreamWriteTransformingEventArgs(new byte[0], 0, 0, Mock.Of<Encoding>())
     {
         TransformedOffset = transformedOffset
     };
     Assert.AreEqual(transformedOffset, streamWriteTransformingEventArgs.TransformedOffset);
     Assert.IsTrue(transformedOffset < 0);
 }
 protected internal virtual void OnTransformWrite(StreamWriteTransformingEventArgs e)
 {
     if(this.HasTransformWriteEvents)
         this.TransformWrite(this, e);
 }