public void TestLengthOnLinearBlock()
        {
            RingMemoryStream testRing = new RingMemoryStream(10);

            testRing.Write(new byte[10], 0, 10);

            Assert.AreEqual(10, testRing.Length);
        }
        public void TestLengthOnSplitBlock()
        {
            RingMemoryStream testRing = new RingMemoryStream(10);

            testRing.Write(new byte[10], 0, 10);
            testRing.Read(new byte[5], 0, 5);
            testRing.Write(new byte[5], 0, 5);

            Assert.AreEqual(10, testRing.Length);
        }
        public void TestCapacityDecreaseException()
        {
            RingMemoryStream testRing = new RingMemoryStream(20);

            testRing.Write(this.testBytes, 0, 20);

            Assert.Throws <ArgumentOutOfRangeException>(
                delegate() { testRing.Capacity = 10; }
                );
        }
    public void TestWriteSplitBlock() {
      RingMemoryStream testRing = new RingMemoryStream(10);
      testRing.Write(this.testBytes, 0, 8);
      testRing.Read(this.testBytes, 0, 5);
      testRing.Write(this.testBytes, 0, 7);

      byte[] actual = new byte[10];
      testRing.Read(actual, 0, 10);
      Assert.AreEqual(new byte[] { 5, 6, 7, 0, 1, 2, 3, 4, 5, 6 }, actual);
    }
        public void TestWriteSplitAndLinearTooLargeBlock()
        {
            RingMemoryStream testRing = new RingMemoryStream(10);

            testRing.Write(this.testBytes, 0, 8);
            testRing.Read(this.testBytes, 0, 5);
            testRing.Write(this.testBytes, 0, 5);
            Assert.Throws <OverflowException>(
                delegate() { testRing.Write(this.testBytes, 0, 3); }
                );
        }
        public void TestCapacityDecrease()
        {
            RingMemoryStream testRing = new RingMemoryStream(20);

            testRing.Write(this.testBytes, 0, 10);

            testRing.Capacity = 10;
            byte[] actual = new byte[10];
            testRing.Read(actual, 0, 10);

            Assert.AreEqual(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, actual);
        }
        public void TestSplitBlockLinearRead()
        {
            RingMemoryStream testRing = new RingMemoryStream(10);

            testRing.Write(this.testBytes, 0, 10);
            testRing.Read(this.testBytes, 0, 5);
            testRing.Write(this.testBytes, 0, 5);

            byte[] actual = new byte[5];
            testRing.Read(actual, 0, 5);
            Assert.AreEqual(new byte[] { 5, 6, 7, 8, 9 }, actual);
        }
        public void TestWriteSplitBlock()
        {
            RingMemoryStream testRing = new RingMemoryStream(10);

            testRing.Write(this.testBytes, 0, 8);
            testRing.Read(this.testBytes, 0, 5);
            testRing.Write(this.testBytes, 0, 7);

            byte[] actual = new byte[10];
            testRing.Read(actual, 0, 10);
            Assert.AreEqual(new byte[] { 5, 6, 7, 0, 1, 2, 3, 4, 5, 6 }, actual);
        }
        public void TestSplitBlockWrappedRead()
        {
            RingMemoryStream testRing = new RingMemoryStream(10);

            testRing.Write(this.testBytes, 0, 10);
            testRing.Read(this.testBytes, 0, 5);
            testRing.Write(this.testBytes, 0, 5);

            byte[] actual = new byte[10];
            testRing.Read(actual, 0, 10);
            Assert.AreEqual(new byte[] { 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 }, actual);
        }
        public void TestAutoReset()
        {
            byte[]           tempBytes = new byte[10];
            RingMemoryStream testRing  = new RingMemoryStream(10);

            testRing.Write(this.testBytes, 0, 8);
            testRing.Read(tempBytes, 0, 2);
            testRing.Read(tempBytes, 0, 2);
            testRing.Read(tempBytes, 0, 1);
            testRing.Read(tempBytes, 0, 1);

            Assert.AreEqual(2, testRing.Length);
        }
        public void TestEndOfStream()
        {
            byte[] tempBytes = new byte[10];

            RingMemoryStream testRing = new RingMemoryStream(10);

            Assert.AreEqual(0, testRing.Read(tempBytes, 0, 5));

            testRing.Write(this.testBytes, 0, 5);
            Assert.AreEqual(5, testRing.Read(tempBytes, 0, 10));

            testRing.Write(this.testBytes, 0, 6);
            testRing.Read(tempBytes, 0, 5);
            testRing.Write(this.testBytes, 0, 9);
            Assert.AreEqual(10, testRing.Read(tempBytes, 0, 20));
        }
    public void TestLengthOnSplitBlock() {
      RingMemoryStream testRing = new RingMemoryStream(10);

      testRing.Write(new byte[10], 0, 10);
      testRing.Read(new byte[5], 0, 5);
      testRing.Write(new byte[5], 0, 5);

      Assert.AreEqual(10, testRing.Length);
    }
    public void TestLengthOnLinearBlock() {
      RingMemoryStream testRing = new RingMemoryStream(10);
      testRing.Write(new byte[10], 0, 10);

      Assert.AreEqual(10, testRing.Length);
    }
    public void TestAutoReset() {
      byte[] tempBytes = new byte[10];
      RingMemoryStream testRing = new RingMemoryStream(10);

      testRing.Write(this.testBytes, 0, 8);
      testRing.Read(tempBytes, 0, 2);
      testRing.Read(tempBytes, 0, 2);
      testRing.Read(tempBytes, 0, 1);
      testRing.Read(tempBytes, 0, 1);

      Assert.AreEqual(2, testRing.Length);
    }
    public void TestCapacity() {
      RingMemoryStream testRing = new RingMemoryStream(123);

      Assert.AreEqual(123, testRing.Capacity);
    }
    public void TestCapacityDecreaseException() {
      RingMemoryStream testRing = new RingMemoryStream(20);
      testRing.Write(this.testBytes, 0, 20);

      Assert.Throws<ArgumentOutOfRangeException>(
        delegate() { testRing.Capacity = 10; }
      );
    }
    public void TestCapacityDecrease() {
      RingMemoryStream testRing = new RingMemoryStream(20);
      testRing.Write(this.testBytes, 0, 10);

      testRing.Capacity = 10;
      byte[] actual = new byte[10];
      testRing.Read(actual, 0, 10);

      Assert.AreEqual(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, actual);
    }
    public void TestEndOfStream() {
      byte[] tempBytes = new byte[10];

      RingMemoryStream testRing = new RingMemoryStream(10);
      Assert.AreEqual(0, testRing.Read(tempBytes, 0, 5));

      testRing.Write(this.testBytes, 0, 5);
      Assert.AreEqual(5, testRing.Read(tempBytes, 0, 10));

      testRing.Write(this.testBytes, 0, 6);
      testRing.Read(tempBytes, 0, 5);
      testRing.Write(this.testBytes, 0, 9);
      Assert.AreEqual(10, testRing.Read(tempBytes, 0, 20));
    }
    public void TestSplitBlockLinearRead() {
      RingMemoryStream testRing = new RingMemoryStream(10);
      testRing.Write(this.testBytes, 0, 10);
      testRing.Read(this.testBytes, 0, 5);
      testRing.Write(this.testBytes, 0, 5);

      byte[] actual = new byte[5];
      testRing.Read(actual, 0, 5);
      Assert.AreEqual(new byte[] { 5, 6, 7, 8, 9 }, actual);
    }
        public void TestCapacity()
        {
            RingMemoryStream testRing = new RingMemoryStream(123);

            Assert.AreEqual(123, testRing.Capacity);
        }
 public void TestWriteSplitAndLinearTooLargeBlock() {
   RingMemoryStream testRing = new RingMemoryStream(10);
   testRing.Write(this.testBytes, 0, 8);
   testRing.Read(this.testBytes, 0, 5);
   testRing.Write(this.testBytes, 0, 5);
   Assert.Throws<OverflowException>(
     delegate() { testRing.Write(this.testBytes, 0, 3); }
   );
 }
    public void TestSplitBlockWrappedRead() {
      RingMemoryStream testRing = new RingMemoryStream(10);
      testRing.Write(this.testBytes, 0, 10);
      testRing.Read(this.testBytes, 0, 5);
      testRing.Write(this.testBytes, 0, 5);

      byte[] actual = new byte[10];
      testRing.Read(actual, 0, 10);
      Assert.AreEqual(new byte[] { 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 }, actual);
    }