public void StartPositionNegative()
        {
            var byteArray = Encoding.ASCII.GetBytes("0123456789");

            using (var memStream = new MemoryStream(byteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.ReadStringInRange(-2, 2);
                }
        }
        public void EndPositionLargerThanStream()
        {
            var byteArray = Encoding.ASCII.GetBytes("0123456789");

            using (var memStream = new MemoryStream(byteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.ReadStringInRange(1, 11);
                }
        }
        public void EmptyStream()
        {
            var emptyByteArray = new byte[0];

            using (var memStream = new MemoryStream(emptyByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.ReadStringInRange(0, 1);
                }
        }
Beispiel #4
0
        public void ZeroLines()
        {
            var byteArray = Encoding.ASCII.GetBytes("0123456789");

            using (var memStream = new MemoryStream(byteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.ReadLines(0);
                }
        }
        public void NullNeedle()
        {
            var haystackByteArray = Encoding.ASCII.GetBytes("This haystack does not contain a n-e-e-d-l-e");

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPosition = sStream.IndexOfAllBackwards(null);
                }
        }
Beispiel #6
0
        public void LessLinesThanAskedFor()
        {
            var byteArray = Encoding.ASCII.GetBytes("0123456789");

            using (var memStream = new MemoryStream(byteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    var result = sStream.ReadLines(10);

                    Assert.AreEqual("0123456789", result);
                }
        }
Beispiel #7
0
        public void GetThreeOfMany()
        {
            var byteArray = Encoding.ASCII.GetBytes("0\n1\n2\n3\n4\n5\n6\n7\n8\n9");

            using (var memStream = new MemoryStream(byteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    var result = sStream.ReadLines(3);

                    Assert.AreEqual("0\n1\n2\n", result);
                }
        }
        public void ReadWholeStream()
        {
            var byteArray = Encoding.ASCII.GetBytes("0123456789");

            using (var memStream = new MemoryStream(byteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    var result = sStream.ReadStringInRange(0, 9);

                    Assert.AreEqual("0123456789", result);
                }
        }
        public void EmptyNeedle()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("This haystack does not contain a n-e-e-d-l-e");
            var emptyNeedle       = string.Empty;

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPosition = sStream.LastIndexOf(emptyNeedle);
                }
        }
Beispiel #10
0
        public void StartPostionPastFirstLine_GetThree()
        {
            var byteArray = Encoding.ASCII.GetBytes("0\n1\n2\n3\n4\n5\n6\n7\n8\n9");

            using (var memStream = new MemoryStream(byteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.Position = 2;
                    var result = sStream.ReadLines(3);

                    Assert.AreEqual("1\n2\n3\n", result);
                }
        }
Beispiel #11
0
        public void EmptyStream()
        {
            // Arrange
            var emptyByteArray  = new byte[0];
            var needleByteArray = "needle";

            using (var memStream = new MemoryStream(emptyByteArray))
                using (var searchableStringStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPositions = searchableStringStream.IndexOfAll(needleByteArray);

                    // Assert
                    Assert.AreEqual(0, foundPositions.Length);
                }
        }
        public void SingleOccuranceAtEnd()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("haystack with a needle");
            var needle            = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPosition = sStream.LastIndexOf(needle);

                    // Assert
                    Assert.AreEqual(16, foundPosition);
                }
        }
        public void NotInStream()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("This haystack does not contain a n-e-e-d-l-e");
            var needle            = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPosition = sStream.LastIndexOf(needle);

                    // Assert
                    Assert.AreEqual(-1, foundPosition);
                }
        }
        public void EmptyStream()
        {
            // Arrange
            var emptyByteArray = new byte[0];
            var needle         = "needle";

            using (var memStream = new MemoryStream(emptyByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPosition = sStream.LastIndexOf(needle);

                    // Assert
                    Assert.AreEqual(-1, foundPosition);
                }
        }
        public void MultipleOccurance()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("This hay stack has a needle here and another needle here and another needle here");
            var needle            = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPosition = sStream.LastIndexOf(needle);

                    // Assert
                    Assert.AreEqual(69, foundPosition);
                }
        }
        public void SingleOccuranceAtBeginning()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("needle in a haystack");
            var needle            = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var searchableStringStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPosition = searchableStringStream.IndexOf(needle);

                    // Assert
                    Assert.AreEqual(0, foundPosition);
                }
        }
Beispiel #17
0
        public void SingleOccuranceAtEnd()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("haystack with a needle");
            var needleByteArray   = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var searchableStringStream = new SearchableStringStream(memStream))
                {
                    // Act
                    var foundPositions = searchableStringStream.IndexOfAll(needleByteArray);

                    // Assert
                    Assert.AreEqual(1, foundPositions.Length);
                    Assert.AreEqual(16, foundPositions[0]);
                }
        }
        public void EmptyStream()
        {
            // Arrange
            var emptyByteArray = new byte[0];
            var needle         = "needle";

            using (var memStream = new MemoryStream(emptyByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.Seek(0, SeekOrigin.End);
                    // Act
                    var foundPositions = sStream.IndexOfAllBackwards(needle);

                    // Assert
                    Assert.AreEqual(0, foundPositions.Length);
                }
        }
Beispiel #19
0
        public void MultipleOccuranceSelectTwo_Unicode()
        {
            // Arrange
            var haystackByteArray = Encoding.Unicode.GetBytes("This hay stack has a needle here and another needle here and another needle here");
            var needleByteArray   = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var searchableStringStream = new SearchableStringStream(memStream, Encoding.Unicode))
                {
                    // Act
                    var foundPositions = searchableStringStream.IndexOfAll(needleByteArray, 2);

                    // Assert
                    Assert.AreEqual(2, foundPositions.Length);
                    Assert.AreEqual(42, foundPositions[0]);
                    Assert.AreEqual(90, foundPositions[1]);
                }
        }
        public void NotInStream()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("This haystack does not contain a n-e-e-d-l-e");
            var needle            = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.Seek(0, SeekOrigin.End);

                    // Act
                    var foundPositions = sStream.IndexOfAllBackwards(needle);

                    // Assert
                    Assert.AreEqual(0, foundPositions.Length);
                }
        }
        public void MultipleOccuranceSelectTwo()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("This hay stack has a needle here and another needle here and another needle here");
            var needle            = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.Seek(0, SeekOrigin.End);
                    // Act
                    var foundPositions = sStream.IndexOfAllBackwards(needle, 2);

                    // Assert
                    Assert.AreEqual(2, foundPositions.Length);
                    Assert.AreEqual(45, foundPositions[1]);
                    Assert.AreEqual(69, foundPositions[0]);
                }
        }
        public void SingleOccuranceAtBeginning()
        {
            // Arrange
            var haystackByteArray = Encoding.ASCII.GetBytes("needle in a haystack");
            var needle            = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var sStream = new SearchableStringStream(memStream))
                {
                    sStream.Seek(0, SeekOrigin.End);

                    // Act
                    var foundPositions = sStream.IndexOfAllBackwards(needle);

                    // Assert
                    Assert.AreEqual(1, foundPositions.Length);
                    Assert.AreEqual(0, foundPositions[0]);
                }
        }
Beispiel #23
0
        public void MultipleOccurance_UTF8()
        {
            // Arrange
            var haystackByteArray = Encoding.UTF8.GetBytes("This hay stack has a needle here and another needle here and another needle here");
            var needleByteArray   = "needle";

            using (var memStream = new MemoryStream(haystackByteArray))
                using (var searchableStringStream = new SearchableStringStream(memStream, Encoding.UTF8))
                {
                    // Act
                    var foundPositions = searchableStringStream.IndexOfAll(needleByteArray);

                    // Assert
                    Assert.AreEqual(3, foundPositions.Length);
                    Assert.AreEqual(21, foundPositions[0]);
                    Assert.AreEqual(45, foundPositions[1]);
                    Assert.AreEqual(69, foundPositions[2]);
                }
        }