C# (CSharp) CParser.PerformParse Examples

Example #1

        public void TestParsingPPFunctionDefinitionWithNoParameters()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.SYMBOL, "FDSA"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, ")"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "("));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            var c = p.PerformParse();

            Assert.That(c, Is.Not.Null);
            Assert.That(c.PreProcessorDefinitions, Is.Not.Empty);

            var pp = c.PreProcessorDefinitions.First();

            Assert.That(pp, Is.Not.Null);
            Assert.That(pp.Identifier, Is.EqualTo("CTokenType"));
            Assert.That(pp.Arguments, Is.Not.Null);
            Assert.That(pp.Arguments, Is.Empty);
            Assert.That(pp.Replacement, Is.EqualTo("FDSA"));
        }

Example #2

        public void TestParsingEmptyLexer()
        {
            var m = SetupMock(new Stack <Token <CTokenType> >());

            var p  = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
        }

Example #3

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParserThrowsExceptionIfLexerThrowsException()
        {
            var m = new Mock<ICLexer>();
            m.SetupGet(l => l.HasMoreTokens).Returns(true);
            m.Setup(l => l.GetNextToken(It.IsAny<bool>())).Throws(new Exception());

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #4

        public void TestParserThrowsExceptionIfLexerThrowsException()
        {
            var m = new Mock <ICLexer>();

            m.SetupGet(l => l.HasMoreTokens).Returns(true);
            m.Setup(l => l.GetNextToken(It.IsAny <bool>())).Throws(new Exception());

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #5

        public void TestParsingInvalidFirstToken()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.TERMINATOR));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #6

        public void TestParsingInvalidPPDirectiveVerb()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.KEYWORD));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #7

        public void TestParsingUnterminatedPPDefinition()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #8

        public void TestParsingElseWithNoStartingIf()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "else"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #9

        public void TestParsingInvalidInclude2()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "."));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #10

        public void TestParsingInvalidPPFunctionDefinitionWithParameters5()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "("));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #11

        public void TestParsingUnknownPPDirective()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "pragma"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p  = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
            m.Verify(l => l.SkipToNextLine());
        }

Example #12

        public void TestParsingValidEndif()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "endif"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL, "", 1));
            tokens.Push(GenerateToken(CTokenType.NUMERIC_LITERAL, "1"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "if"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p  = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(() => sf.PopIfCond(), Throws.TypeOf(typeof(InvalidOperationException)));
        }

Example #13

        public void TestParsingIncludeStringLiteral()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.STRING_LITERAL, "\"test.h\""));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p  = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
            Assert.That(sf.IncludeList.Count, Is.EqualTo(1));
            Assert.That(sf.IncludeList.ElementAt(0).File, Is.EqualTo("test.h"));
            Assert.That(sf.IncludeList.ElementAt(0).IsStandard, Is.False);
        }

Example #14

        public void TestParsingValidIfndefCondition()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.NUMERIC_LITERAL, "TEST"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "ifndef"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p  = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
            var str = sf.PopIfCond();

            Assert.That(str, Is.Not.Null);
            Assert.That(str, Is.EqualTo("!defined(TEST)"));
        }

Example #15

        public void TestParsingIncludeStandard()
        {
            Stack <Token <CTokenType> > tokens = new Stack <Token <CTokenType> >();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, ">"));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "h"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "."));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "test"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "<"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p  = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
            Assert.That(sf.IncludeList.Count, Is.EqualTo(1));
            Assert.That(sf.IncludeList.ElementAt(0).File, Is.EqualTo("test.h"));
            Assert.That(sf.IncludeList.ElementAt(0).IsStandard, Is.True);
        }

Example #16

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingBasicPPDefinition()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.SYMBOL, "FDSA"));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            var c = p.PerformParse();

            Assert.That(c, Is.Not.Null);
            Assert.That(c.PreProcessorDefinitions, Is.Not.Empty);

            var pp = c.PreProcessorDefinitions.First();
            Assert.That(pp, Is.Not.Null);
            Assert.That(pp.Identifier, Is.EqualTo("CTokenType"));
            Assert.That(pp.Arguments, Is.Null);
            Assert.That(pp.Replacement, Is.EqualTo("FDSA"));
        }

Example #17

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingEmptyLexer()
        {
            var m = SetupMock(new Stack<Token<CTokenType>>());

            var p = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
        }

Example #18

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingUnterminatedStandardInclude()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.SYMBOL, "h"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "."));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "test"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "<"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #19

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingValidEndif()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "endif"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL, "", 1));
            tokens.Push(GenerateToken(CTokenType.NUMERIC_LITERAL, "1"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "if"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            var sf = p.PerformParse();
            Assert.That(() => sf.PopIfCond(), Throws.TypeOf(typeof(InvalidOperationException)));
        }

Example #20

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingValidIfndefCondition()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.NUMERIC_LITERAL, "TEST"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "ifndef"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            var sf = p.PerformParse();
            Assert.That(sf, Is.Not.Null);
            var str = sf.PopIfCond();
            Assert.That(str, Is.Not.Null);
            Assert.That(str, Is.EqualTo("!defined(TEST)"));
        }

Example #21

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingUnterminatedPPDefinition()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #22

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingPPFunctionDefinitionWithParameters()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.SYMBOL, "FDSA"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, ")"));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "b"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, ","));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "a"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "("));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            var c = p.PerformParse();

            Assert.That(c, Is.Not.Null);
            Assert.That(c.PreProcessorDefinitions, Is.Not.Empty);

            var pp = c.PreProcessorDefinitions.First();
            Assert.That(pp, Is.Not.Null);
            Assert.That(pp.Identifier, Is.EqualTo("CTokenType"));

            Assert.That(pp.Arguments, Is.Not.Null);
            Assert.That(pp.Arguments, Is.Not.Empty);
            var a = pp.Arguments.First();
            Assert.That(a, Is.Not.Null);
            Assert.That(a, Is.EqualTo("a"));
            var b = pp.Arguments.ElementAt(1);
            Assert.That(b, Is.Not.Null);
            Assert.That(b, Is.EqualTo("b"));

            Assert.That(pp.Replacement, Is.EqualTo("FDSA"));
        }

Example #23

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingUnknownPPDirectiveSymbol()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.SYMBOL));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
            m.Verify(l => l.SkipToNextLine());
        }

Example #24

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingInvalidPPFunctionDefinitionWithParameters5()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "("));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "CTokenType"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "define"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #25

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingInvalidPPDirectiveVerb()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.KEYWORD));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #26

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingInvalidInclude()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.INVALID));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #27

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingInvalidFirstToken()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.TERMINATOR));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #28

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingIncludeStringLiteral()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.STRING_LITERAL, "\"test.h\""));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
            Assert.That(sf.IncludeList.Count, Is.EqualTo(1));
            Assert.That(sf.IncludeList.ElementAt(0).File, Is.EqualTo("test.h"));
            Assert.That(sf.IncludeList.ElementAt(0).IsStandard, Is.False);
        }

Example #29

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingElifWithNoStartingIf()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "elif"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);

            Assert.That(() => p.PerformParse(), Throws.TypeOf(typeof(ParserException)));
        }

Example #30

File: CParserTest.cs Project: juntalis/CHeaderGenerator

        public void TestParsingIncludeStandard()
        {
            Stack<Token<CTokenType>> tokens = new Stack<Token<CTokenType>>();

            var m = SetupMock(tokens);

            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, ">"));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "h"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "."));
            tokens.Push(GenerateToken(CTokenType.SYMBOL, "test"));
            tokens.Push(GenerateToken(CTokenType.PUNCTUATOR, "<"));
            tokens.Push(GenerateToken(CTokenType.PP_DIRECTIVE, "include"));
            tokens.Push(GenerateToken(CTokenType.PP_SYMBOL));

            var p = new CParser(m.Object);
            var sf = p.PerformParse();

            Assert.That(sf, Is.Not.Null);
            Assert.That(sf.IncludeList.Count, Is.EqualTo(1));
            Assert.That(sf.IncludeList.ElementAt(0).File, Is.EqualTo("test.h"));
            Assert.That(sf.IncludeList.ElementAt(0).IsStandard, Is.True);
        }