Example #1
0
        public virtual void ReadingEmptyByteArrayWithOffsetAndZeroLimitTest()
        {
            LimitedInputStream stream = new LimitedInputStream(new MemoryStream(new byte[0]), 0);

            byte[] bytes = new byte[100];
            NUnit.Framework.Assert.AreEqual(-1, stream.JRead(bytes, 0, 100));
        }
Example #2
0
        public virtual void ReadingByteWithZeroLimitTest()
        {
            LimitedInputStream stream = new LimitedInputStream(new MemoryStream(new byte[1]), 0);

            NUnit.Framework.Assert.That(() => {
                stream.Read();
            }
                                        , NUnit.Framework.Throws.InstanceOf <ReadingByteLimitException>())
            ;
        }
Example #3
0
        public virtual void ReadingByteArrayWithOffsetAndZeroLimitTest()
        {
            LimitedInputStream stream = new LimitedInputStream(new MemoryStream(new byte[1]), 0);

            byte[] bytes = new byte[100];
            NUnit.Framework.Assert.That(() => {
                stream.JRead(bytes, 0, 100);
            }
                                        , NUnit.Framework.Throws.InstanceOf <ReadingByteLimitException>())
            ;
        }
Example #4
0
        public virtual void ReadingByteArrayWithOffsetAfterFileReadingTest()
        {
            UriResolver uriResolver = new UriResolver(baseUri);
            Uri         url         = uriResolver.ResolveAgainstBaseUri("retrieveStyleSheetTest.css.dat");
            // retrieveStyleSheetTest.css.dat size is 89 bytes
            Stream stream = new LimitedInputStream(UrlUtil.OpenStream(url), 100);

            // The user can call the reading methods as many times as he want, and if the
            // stream has been read, then should not throw an ReadingByteLimitException exception
            stream.JRead(new byte[100], 0, 100);
            stream.JRead(new byte[1], 0, 1);
        }
Example #5
0
        public virtual void ByteArrayOverwritingTest()
        {
            UriResolver uriResolver = new UriResolver(baseUri);
            Uri         url         = uriResolver.ResolveAgainstBaseUri("retrieveStyleSheetTest.css.dat");
            // retrieveStyleSheetTest.css.dat size is 89 bytes
            Stream stream = new LimitedInputStream(UrlUtil.OpenStream(url), 90);

            byte[] bytes = new byte[100];
            bytes[89] = 13;
            NUnit.Framework.Assert.AreEqual(89, stream.Read(bytes));
            // Check that when calling the read(byte[]) method, as many bytes were copied into
            // the original array as were read, and not all bytes from the auxiliary array.
            NUnit.Framework.Assert.AreEqual(13, bytes[89]);
        }
Example #6
0
        public virtual void ReadingByteArrayWithOffsetAndBigBufferTest()
        {
            UriResolver uriResolver = new UriResolver(baseUri);
            Uri         url         = uriResolver.ResolveAgainstBaseUri("retrieveStyleSheetTest.css.dat");
            // retrieveStyleSheetTest.css.dat size is 89 bytes
            Stream stream = new LimitedInputStream(UrlUtil.OpenStream(url), 89);

            byte[] bytes = new byte[100];
            NUnit.Framework.Assert.AreEqual(89, stream.JRead(bytes, 0, 100));
            byte[] tempBytes = (byte[])bytes.Clone();
            NUnit.Framework.Assert.AreEqual(-1, stream.JRead(bytes, 0, 100));
            // Check that the array has not changed when we have read the entire LimitedInputStream
            NUnit.Framework.Assert.AreEqual(tempBytes, bytes);
        }
Example #7
0
        public virtual void ReadingByteWithLimitOfOneLessThenFileSizeTest()
        {
            UriResolver uriResolver = new UriResolver(baseUri);
            Uri         url         = uriResolver.ResolveAgainstBaseUri("retrieveStyleSheetTest.css.dat");
            // retrieveStyleSheetTest.css.dat size is 89 bytes
            Stream stream = new LimitedInputStream(UrlUtil.OpenStream(url), 88);

            for (int i = 0; i < 88; i++)
            {
                NUnit.Framework.Assert.AreNotEqual(-1, stream.Read());
            }
            NUnit.Framework.Assert.That(() => {
                stream.Read();
            }
                                        , NUnit.Framework.Throws.InstanceOf <ReadingByteLimitException>())
            ;
        }
Example #8
0
        public virtual void ReadingByteArrayWithLimitOfOneLessThenFileSizeTest()
        {
            UriResolver uriResolver = new UriResolver(baseUri);
            Uri         url         = uriResolver.ResolveAgainstBaseUri("retrieveStyleSheetTest.css.dat");
            // retrieveStyleSheetTest.css.dat size is 89 bytes
            Stream stream = new LimitedInputStream(UrlUtil.OpenStream(url), 88);

            byte[] bytes          = new byte[100];
            int    numOfReadBytes = stream.Read(bytes);

            NUnit.Framework.Assert.AreEqual(88, numOfReadBytes);
            NUnit.Framework.Assert.AreEqual(10, bytes[87]);
            NUnit.Framework.Assert.AreEqual(0, bytes[88]);
            NUnit.Framework.Assert.That(() => {
                stream.Read(new byte[1]);
            }
                                        , NUnit.Framework.Throws.InstanceOf <ReadingByteLimitException>())
            ;
        }
Example #9
0
        public virtual void ReadingByteArrayWithSmallBufferTest()
        {
            UriResolver uriResolver = new UriResolver(baseUri);
            Uri         url         = uriResolver.ResolveAgainstBaseUri("retrieveStyleSheetTest.css.dat");
            // retrieveStyleSheetTest.css.dat size is 89 bytes
            Stream stream = new LimitedInputStream(UrlUtil.OpenStream(url), 89);

            byte[]       bytes  = new byte[20];
            MemoryStream output = new MemoryStream();

            while (true)
            {
                int read = stream.Read(bytes);
                if (read < 1)
                {
                    break;
                }
                output.Write(bytes, 0, read);
            }
            NUnit.Framework.Assert.AreEqual(89, output.Length);
            output.Dispose();
        }
Example #10
0
        public virtual void ReadingEmptyByteWithZeroLimitTest()
        {
            LimitedInputStream stream = new LimitedInputStream(new MemoryStream(new byte[0]), 0);

            NUnit.Framework.Assert.AreEqual(-1, stream.Read());
        }