public SpanConstructor Accepts(AcceptedCharacters accepted)
 {
     return With(eh => eh.AcceptedCharacters = accepted);
 }

 public Block EscapedMarkupTagBlock(string prefix, string suffix, AcceptedCharacters acceptedCharacters)
 {
     return new MarkupTagBlock(
         _factory.Markup(prefix),
         _factory.BangEscape(),
         _factory.Markup(suffix).Accepts(acceptedCharacters));
 }

 public static void RunSingleAtEscapeTest(Action<string, Block> testMethod, AcceptedCharacters lastSpanAcceptedCharacters = AcceptedCharacters.None) {
     testMethod("<foo>@@bar</foo>",
                 new MarkupBlock(
                     new MarkupSpan("<foo>"),
                     new MarkupSpan("@", hidden: true),
                     new MarkupSpan("@bar</foo>", hidden: false, acceptedCharacters: lastSpanAcceptedCharacters)
                 )
               );
 }

 public static void RunSingleAtEscapeTest(Action<string, Block> testMethod, AcceptedCharacters lastSpanAcceptedCharacters = AcceptedCharacters.None)
 {
     var factory = SpanFactory.CreateCsHtml();
     testMethod("<foo>@@bar</foo>",
         new MarkupBlock(
             factory.Markup("<foo>"),
             factory.Markup("@").Hidden(),
             factory.Markup("@bar</foo>").Accepts(lastSpanAcceptedCharacters)));
 }

 protected void ImplicitExpressionTest(string input, string expected, AcceptedCharacters acceptedCharacters, params RazorError[] errors) {
     ParseBlockTest(input,
                    new ExpressionBlock(
                       new ImplicitExpressionSpan(expected, 
                                                  CSharpCodeParser.DefaultKeywords, 
                                                  acceptTrailingDot: false,
                                                  acceptedCharacters: acceptedCharacters)),
                    errors);
 }

 protected void ImplicitExpressionTest(string input, string expected, AcceptedCharacters acceptedCharacters, params RazorError[] errors)
 {
     var factory = CreateSpanFactory();
     ParseBlockTest(SyntaxConstants.TransitionString + input,
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code(expected)
                            .AsImplicitExpression(KeywordSet)
                            .Accepts(acceptedCharacters)),
                    errors);
 }

 public void ParseBlockMethodParsesNullConditionalOperatorImplicitExpression_Bracket(
     string implicitExpresison,
     string expectedImplicitExpression,
     AcceptedCharacters acceptedCharacters,
     RazorError[] expectedErrors)
 {
     // Act & Assert
     ImplicitExpressionTest(
         implicitExpresison,
         expectedImplicitExpression,
         acceptedCharacters,
         expectedErrors);
 }

 public static void RunMultiAtEscapeTest(Action<string, Block> testMethod, AcceptedCharacters lastSpanAcceptedCharacters = AcceptedCharacters.None) {
     testMethod("<foo>@@@@@bar</foo>", 
                 new MarkupBlock(
                     new MarkupSpan("<foo>"),
                     new MarkupSpan("@", hidden: true),
                     new MarkupSpan("@"),
                     new MarkupSpan("@", hidden: true),
                     new MarkupSpan("@"),
                     new ExpressionBlock(
                         new TransitionSpan(RazorParser.TransitionString, hidden: false, acceptedCharacters: AcceptedCharacters.None),
                         new ImplicitExpressionSpan("bar", CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false, acceptedCharacters: AcceptedCharacters.NonWhiteSpace)
                     ),
                     new MarkupSpan("</foo>", hidden: false, acceptedCharacters: lastSpanAcceptedCharacters)
                 ));
 }

 public void SimpleMarkupSwitch(string keyword, string endSequence, AcceptedCharacters acceptedCharacters)
 {
     ParseBlockTest(keyword + Environment.NewLine
                  + "    If True Then" + Environment.NewLine
                  + "        @<p>It's True!</p>" + Environment.NewLine
                  + "    End If" + Environment.NewLine
                  + endSequence,
         new StatementBlock(
             Factory.Code(keyword + "\r\n    If True Then\r\n").AsStatement(),
             new MarkupBlock(
                 Factory.Markup("        "),
                 Factory.MarkupTransition(),
                 Factory.Markup("<p>It's True!</p>\r\n").Accepts(AcceptedCharacters.None)),
             Factory.Code("    End If\r\n" + endSequence).AsStatement().Accepts(acceptedCharacters)));
 }

 public static void RunMultiAtEscapeTest(Action<string, Block> testMethod, AcceptedCharacters lastSpanAcceptedCharacters = AcceptedCharacters.None)
 {
     var factory = SpanFactory.CreateCsHtml();
     testMethod("<foo>@@@@@bar</foo>",
         new MarkupBlock(
             factory.Markup("<foo>"),
             factory.Markup("@").Hidden(),
             factory.Markup("@"),
             factory.Markup("@").Hidden(),
             factory.Markup("@"),
             new ExpressionBlock(
                 factory.CodeTransition(),
                 factory.Code("bar")
                        .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                        .Accepts(AcceptedCharacters.NonWhiteSpace)),
             factory.Markup("</foo>").Accepts(lastSpanAcceptedCharacters)));
 }

        public Block EscapedMarkupTagBlock(
            string prefix,
            string suffix,
            AcceptedCharacters acceptedCharacters,
            params SyntaxTreeNode[] children)
        {
            var newChildren = new List<SyntaxTreeNode>(
                new SyntaxTreeNode[]
                {
                    _factory.Markup(prefix),
                    _factory.BangEscape(),
                    _factory.Markup(suffix).Accepts(acceptedCharacters)
                });

            newChildren.AddRange(children);

            return new MarkupTagBlock(newChildren.ToArray());
        }

 public void SingleLineMarkupSwitch(string keyword, string endSequence, AcceptedCharacters acceptedCharacters)
 {
     ParseBlockTest(keyword + Environment.NewLine
                  + "    If True Then" + Environment.NewLine
                  + "        @:<p>It's True!</p>" + Environment.NewLine
                  + "        This is code!" + Environment.NewLine
                  + "    End If" + Environment.NewLine
                  + endSequence,
         new StatementBlock(
             Factory.Code(keyword + "\r\n    If True Then\r\n").AsStatement(),
             new MarkupBlock(
                 Factory.Markup("        "),
                 Factory.MarkupTransition(),
                 Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                 Factory.Markup("<p>It's True!</p>\r\n")
                         .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString))
                         .Accepts(AcceptedCharacters.None)),
             Factory.Code("        This is code!\r\n    End If\r\n" + endSequence)
                     .AsStatement()
                     .Accepts(acceptedCharacters)));
 }

 public SingleLineMarkupEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer, AcceptedCharacters accepted)
     : base(tokenizer, accepted)
 {
 }

 public static ImplicitExpressionSpan Create(ParserContext context, ISet<string> keywords, bool acceptTrailingDot, AcceptedCharacters acceptedCharacters) {
     return new ImplicitExpressionSpan(context.CurrentSpanStart, context.ContentBuffer.ToString(), keywords, acceptTrailingDot, acceptedCharacters);
 }

 public CommentSpan(SourceLocation start, string content, bool hidden, AcceptedCharacters acceptedCharacters) : base(SpanKind.Comment, start, content, hidden, acceptedCharacters) { }

 public AutoCompleteEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer, AcceptedCharacters accepted)
     : base(tokenizer, accepted)
 {
 }

 internal ImplicitExpressionSpan(string content, ISet<string> keywords, bool acceptTrailingDot, AcceptedCharacters acceptedCharacters)
     : base(content) {
     Keywords = keywords ?? new HashSet<string>();
     AcceptTrailingDot = acceptTrailingDot;
     AcceptedCharacters = acceptedCharacters;
 }

 protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
 {
     SingleSpanBlockTest(document, spanContent, blockType, spanType, acceptedCharacters, expectedErrors: null);
 }

 public static SpanConstructor Accepts(this SpanConstructor self, AcceptedCharacters accepted)
 {
     return self.With(eh => eh.AcceptedCharacters = accepted);
 }

 protected virtual Block CreateSimpleBlockAndSpan(string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
 {
     var span = Factory.Span(spanType, spanContent, spanType == SpanKind.Markup).Accepts(acceptedCharacters);
     var b = new BlockBuilder()
     {
         Type = blockType
     };
     return ConfigureAndAddSpanToBlock(b, span);
 }