public SpanConstructor(SpanKind kind, IEnumerable<ISymbol> symbols)
 {
     Builder = new SpanBuilder();
     Builder.Kind = kind;
     Builder.EditHandler = SpanEditHandler.CreateDefault(TestTokenizer);
     foreach (ISymbol sym in symbols)
     {
         Builder.Accept(sym);
     }
 }

		public Span Span(SpanKind kind, params ISymbol[] symbols)
		{
			var builder = new SpanBuilder();
			builder.Kind = kind;

			foreach (var symbol in symbols)
			{
				builder.Accept(symbol);
			}

			var span = builder.Build();
			if (_last != null)
			{
				span.Previous = _last;
				_last.Next = span;
			}
			_last = span;

			return span;
		}

 public TestSimpleSpan(SpanKind kind, string content, AcceptedCharacters acceptedCharacters) : base(kind, content, hidden: false, acceptedCharacters: acceptedCharacters) { }

 protected virtual void SingleSpanDocumentTest(string document, BlockType blockType, SpanKind spanType)
 {
     Block b = CreateSimpleBlockAndSpan(document, blockType, spanType);
     ParseDocumentTest(document, b);
 }

        private static Span[] GenerateSpans(string text, SpanKind spanKind, int spanIndex, string spanText)
        {
            Assert.True(spanIndex > 0);

            RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());

            Span[] spans;

            using (var reader = new StringReader(text))
            {
                ParserResults results = parser.Parse(reader);
                spans = results.Document.Flatten().ToArray();
            }

            Assert.True(spans.Length > spanIndex);
            Assert.Equal(spanKind, spans[spanIndex].Kind);
            Assert.Equal(spanText, spans[spanIndex].Content);

            return spans;
        }

 private SpanConstructor CreateSymbolSpan(SpanKind kind, string content, Func<SourceLocation, ISymbol> ctor)
 {
     var start = LocationTracker.CurrentLocation;
     LocationTracker.UpdateLocation(content);
     return new SpanConstructor(kind, new[] { ctor(start) });
 }

 public SpanConstructor Span(SpanKind kind, string[] content, bool markup)
 {
     return new SpanConstructor(kind, Tokenize(content, markup));
 }

 public static NamespaceImportSpan Create(ParserContext context, AcceptedCharacters acceptedCharacters, SpanKind kind, string ns, int namespaceKeywordLength) {
     return new NamespaceImportSpan(kind, context.CurrentSpanStart, context.ContentBuffer.ToString(), acceptedCharacters, ns, namespaceKeywordLength);
 }

 public NamespaceImportSpan(SpanKind kind, SourceLocation start, string content, AcceptedCharacters acceptedCharacters, string ns, int namespaceKeywordLength)
     : base(kind, start, content, hidden: false, acceptedCharacters: acceptedCharacters) {
     Namespace = ns;
     NamespaceKeywordLength = namespaceKeywordLength;
 }

 protected Span(ParserContext context, SpanKind kind, bool hidden, AcceptedCharacters acceptedCharacters) : this(kind, context.CurrentSpanStart, context.ContentBuffer.ToString(), hidden, acceptedCharacters) { }

 /// <summary>
 /// Test span to simplify the generation of the actual Span in test initializer.
 /// </summary>
 /// <param name="kind">Span kind</param>
 /// <param name="start">Zero indexed start char index in the buffer.</param>
 /// <param name="end">End Column, if the text length is zero Start == End.</param>
 public TestSpan(SpanKind kind, int start, int end)
 {
     Kind = kind;
     Start = start;
     End = end;
 }

        private static Span GenerateSpan(string text, SpanKind spanKind, int spanIndex, string spanText)
        {
            Span[] spans = GenerateSpans(text, spanKind, spanIndex, spanText);

            return spans[spanIndex];
        }

        private void CompleteTagBlockWithSpan(IDisposable tagBlockWrapper,
                                              AcceptedCharacters acceptedCharacters,
                                              SpanKind spanKind)
        {
            Debug.Assert(tagBlockWrapper != null,
                "Tag block wrapper should not be null when attempting to complete a block");

            Span.EditHandler.AcceptedCharacters = acceptedCharacters;
            // Write out the current span into the block before closing it.
            Output(spanKind);
            // Finish the tag block
            tagBlockWrapper.Dispose();
        }

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

 internal virtual void SingleSpanDocumentTest(string document, BlockType blockType, SpanKind spanType) {
     ParseDocumentTest(document, new Block(blockType, new[] { new TestSimpleSpan(spanType, document) }));
 }

 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);
 }

 protected override void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters, params RazorError[] expectedErrors)
 {
     var b = CreateSimpleBlockAndSpan(spanContent, blockType, spanType, acceptedCharacters);
     ParseBlockTest(document, b, expectedErrors ?? new RazorError[0]);
 }