public void ForEachMatch_ArgumentNullException_Input()
        {
            // Arrange
            var s = new StringSearchModifierBaseTestImplementation();

            // Act & Assert
            Assert.Throws <ArgumentNullException>(() => s.ForEachMatchBase(null, null, 0, null));
        }
        public void SearchStatementRange_ArgumentNullException_Input()
        {
            // Arrange
            var s = new StringSearchModifierBaseTestImplementation();

            // Act & Assert
            Assert.Throws <ArgumentNullException>(() => s.SearchStatementRangeBase(null, null, 0, 0));
        }
        public void ForEachMatch_InvalidOperationException_ModifiedIsNull()
        {
            // Arrange
            var          modifier  = new Func <string, string>(range => null);
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string statement = @"[dbo].";

            // Act & Assert
            Assert.Throws <InvalidOperationException>(() => s.ForEachMatchBase(MultiLineInputWithFinalGo, statement, 0, modifier));
        }
        public void ForEachMatch_ArgumentNullException_Modifier()
        {
            // Arrange
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string input     = "input";
            const string statement = "statement";

            // Act & Assert
            Assert.Throws <ArgumentNullException>(() => s.ForEachMatchBase(input, statement, 0, null));
        }
        public void SearchStatementRange_ArgumentOutOfRangeException_StartAfterIndex()
        {
            // Arrange
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string input     = @"";
            const string statement = @"a";

            // Act & Assert
            Assert.Throws <ArgumentOutOfRangeException>(() => s.SearchStatementRangeBase(input, statement, -1, 0));
        }
        public void ForEachMatch_ArgumentException_Statement()
        {
            // Arrange
            var          modifier  = new Func <string, string>(range => range);
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string input     = @"";
            const string statement = @"";

            // Act & Assert
            Assert.Throws <ArgumentException>(() => s.ForEachMatchBase(input, statement, 0, modifier));
        }
        public void SearchStatementRange_NoMatch()
        {
            // Arrange
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string input     = @"";
            const string statement = @"a";

            // Act
            var(startIndex, endIndex) = s.SearchStatementRangeBase(input, statement, 0, 0);

            // Assert
            Assert.AreEqual(-1, startIndex, "Wrong start index");
            Assert.AreEqual(-1, endIndex, "Wrong end index");
        }
        public void SearchStatementRange_SingleStatementAtEnd_WithoutFinalGo(int startAfterIndex,
                                                                             byte numberOfLeadingStatementsToInclude,
                                                                             int expectedStartIndex,
                                                                             int expectedEndIndex)
        {
            // Arrange
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string statement = @"'Update complete'";

            // Act
            var(startIndex, endIndex) = s.SearchStatementRangeBase(MultiLineInputWithoutFinalGo, statement, startAfterIndex, numberOfLeadingStatementsToInclude);

            // Assert
            Assert.AreEqual(expectedStartIndex, startIndex, "Wrong start index");
            Assert.AreEqual(expectedEndIndex, endIndex, "Wrong end index");
        }
        public void ForEachMatch_ReplaceMultipleMatchesIncludeLeadingStatement()
        {
            // Arrange
            var modifierCalled = false;
            var modifier       = new Func <string, string>(range =>
            {
                modifierCalled = true;
                return(range.Replace("dbo", "config").Replace("statement", "go"));
            });
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string statement = @"[dbo].";

            // Act
            var modified = s.ForEachMatchBase(MultiLineInputWithFinalGo, statement, 1, modifier);

            // Assert
            Assert.IsTrue(modifierCalled);
            Assert.AreEqual(MultiLineInputWithFinalGoWithDifferentSchemaAndPrints, modified);
        }
        public void ForEachMatch_ReplaceMultipleMatches_PreventOverlapping()
        {
            // Arrange
            var modifierCalled = false;
            var modifier       = new Func <string, string>(range =>
            {
                modifierCalled = true;
                return(range.Replace("[dbo].", "/*[dbo].*/"));
            });
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string statement = @"[dbo].";

            // Act
            var modified = s.ForEachMatchBase(MultiLineInputWithFinalGo, statement, 5, modifier);

            // Assert
            Assert.IsTrue(modifierCalled);
            Assert.AreEqual(MultiLineInputWithFinalGoWithoutOverlappingComments, modified);
        }
        public void ForEachMatch_NoMatch()
        {
            // Arrange
            var modifierCalled = false;
            var modifier       = new Func <string, string>(range =>
            {
                modifierCalled = true;
                return(range);
            });
            var          s         = new StringSearchModifierBaseTestImplementation();
            const string input     = @"foobar";
            const string statement = @"test";

            // Act
            var modified = s.ForEachMatchBase(input, statement, 0, modifier);

            // Assert
            Assert.IsFalse(modifierCalled);
            Assert.AreEqual("foobar", modified);
        }