public void ParseModelKeyword_ErrorOnInheritsFollowedByModel()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
                @"@inherits Bar
@model Foo";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("inherits ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Bar\r\n")
                    .As(new SetBaseTypeCodeGenerator("Bar")),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}<{1}>"))
            };

            var expectedErrors = new[]
            {
                new RazorError("The 'inherits' keyword is not allowed when a 'model' keyword is used.", new SourceLocation(9, 0, 9), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.Equal(i.expected, i.span));
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }
        public void ParseModelKeyword_ErrorOnModelFollowedByInherits() {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
@"@ModelType Foo
@inherits Bar";
            var spans = ParseDocument(document, errors);

            // Assert
            var expectedSpans = new Span[] {
                new TransitionSpan(new SourceLocation(0, 0, 0), "@") { AcceptedCharacters = AcceptedCharacters.None },
                new MetaCodeSpan(new SourceLocation(1, 0, 1), "ModelType ") { AcceptedCharacters = AcceptedCharacters.None },
                new ModelSpan(new SourceLocation(11, 0, 11), "Foo\r\n", "Foo"),
                new TransitionSpan(new SourceLocation(16, 1, 0), "@") { AcceptedCharacters = AcceptedCharacters.None },
                new MetaCodeSpan(new SourceLocation(17, 1, 1), "inherits ") { AcceptedCharacters = AcceptedCharacters.None },
                new InheritsSpan(new SourceLocation(26, 1, 10), "Bar", "Bar")
            };

            var expectedErrors = new[] {
                new RazorError("The 'inherits' keyword is not allowed when a 'ModelType' keyword is used.", new SourceLocation(25, 1, 9), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.AreEqual(i.expected, i.span));
            CollectionAssert.AreEqual(expectedSpans, spans, "Spans do not match");
            CollectionAssert.AreEqual(expectedErrors, errors, "Errors do not match");
        }
        public void ParseModelKeyword_ErrorOnMultipleModelStatements()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
                @"@model Foo
@model Bar";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}<{1}>")),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Bar")
                    .As(new SetModelTypeCodeGenerator("Bar", "{0}<{1}>"))
            };

            var expectedErrors = new[]
            {
                new RazorError("Only one 'model' statement is allowed in a file.", new SourceLocation(18, 1, 6), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.Equal(i.expected, i.span));
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }
        public void ParseModelKeyword_ErrorOnMultipleModelStatements() {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
@"@ModelType Foo
@ModelType Bar";
            var spans = ParseDocument(document, errors);

            // Assert
            var expectedSpans = new Span[] {
                new TransitionSpan(new SourceLocation(0, 0, 0), "@") { AcceptedCharacters = AcceptedCharacters.None },
                new MetaCodeSpan(new SourceLocation(1, 0, 1), "ModelType ") { AcceptedCharacters = AcceptedCharacters.None },
                new ModelSpan(new SourceLocation(11, 0, 11), "Foo\r\n", "Foo"),
                new TransitionSpan(new SourceLocation(16, 1, 0), "@") { AcceptedCharacters = AcceptedCharacters.None },
                new MetaCodeSpan(new SourceLocation(17, 1, 1), "ModelType ") { AcceptedCharacters = AcceptedCharacters.None },
                new ModelSpan(new SourceLocation(27, 1, 11), "Bar", "Bar"),
            };

            var expectedErrors = new[] {
                new RazorError("Only one 'ModelType' statement is allowed in a file.", new SourceLocation(26, 1, 10), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.AreEqual(i.expected, i.span));
            CollectionAssert.AreEqual(expectedSpans, spans);
            CollectionAssert.AreEqual(expectedErrors, errors);
        }