IronRuby.Tests.Tests.Parser1 C# (CSharp) Method

        public void Parser1() {
            LoggingErrorSink log = new LoggingErrorSink();

            List<Tokens> tokens;

            tokens = GetRubyTokens(log, "foo (while (f do end) do end) do end");

            Assert(tokens.Count == 14);
            Assert(tokens[0] == Tokens.Identifier);
            Assert(tokens[1] == Tokens.LeftArgParenthesis);
            Assert(tokens[2] == Tokens.While);
            Assert(tokens[3] == Tokens.LeftExprParenthesis);
            Assert(tokens[4] == Tokens.Identifier);
            Assert(tokens[5] == Tokens.Do);
            Assert(tokens[6] == Tokens.End);
            Assert(tokens[7] == Tokens.RightParenthesis);
            Assert(tokens[8] == Tokens.LoopDo);
            Assert(tokens[9] == Tokens.End);
            Assert(tokens[10] == Tokens.RightParenthesis);
            Assert(tokens[11] == Tokens.BlockDo);
            Assert(tokens[12] == Tokens.End);
            Assert(tokens[13] == Tokens.EndOfFile);

            log.Errors.Clear();

            tokens = GetRubyTokens(log, "print 'foo'");

            Assert(log.Errors.Count == 0);

            Assert(tokens.Count == 5 &&
                tokens[0] == Tokens.Identifier &&
                tokens[1] == Tokens.StringBegin &&
                tokens[2] == Tokens.StringContent &&
                tokens[3] == Tokens.StringEnd &&
                tokens[4] == Tokens.EndOfFile);

            Assert(log.Errors.Count == 0);

            tokens = GetRubyTokens(log, "print '");

            Assert(log.Errors.Count == 1 &&
                log.Errors[0].Severity == Severity.Error
            );

            Assert(tokens.Count == 4 &&
                tokens[0] == Tokens.Identifier &&
                tokens[1] == Tokens.StringBegin &&
                tokens[2] == Tokens.StringEnd &&
                tokens[3] == Tokens.EndOfFile);

            log.Errors.Clear();

            tokens = GetRubyTokens(log, "f \"a#{g.h /x/}\" do\nend");

            Assert(tokens.ToArray().ValueEquals(new[] {
                Tokens.Identifier,
                Tokens.StringBegin,
                Tokens.StringContent,
                Tokens.StringEmbeddedCodeBegin,
                Tokens.Identifier,
                Tokens.Dot,
                Tokens.Identifier,
                Tokens.RegexpBegin,
                Tokens.StringContent,
                Tokens.RegexpEnd,
                Tokens.StringEmbeddedCodeEnd,
                Tokens.StringEnd,
                Tokens.BlockDo,
                Tokens.End,
                Tokens.EndOfFile
            }));

            Assert(log.Errors.Count == 1 &&
                log.Errors[0].Severity == Severity.Warning
            );

            log.Errors.Clear();

            // 1.9:
            tokens = GetRubyTokens(log, "def !@\nend");

            Assert(tokens.ToArray().ValueEquals(new[] {
                Tokens.Def,
                Tokens.Bang,
                Tokens.NewLine,
                Tokens.End,
                Tokens.EndOfFile
            }));

            Assert(log.Errors.Count == 0);

            // 1.9:
            tokens = GetRubyTokens(log, "puts <<L, foo\n  .bar\nL\n  .baz");
            Assert(tokens.ToArray().ValueEquals(new[] {
		        Tokens.Identifier,
		        Tokens.StringBegin,
		        Tokens.StringContent,
		        Tokens.StringEnd,
		        Tokens.Comma,
		        Tokens.Identifier,
		        Tokens.Dot,
		        Tokens.Identifier,
		        Tokens.EndOfFile,
            }));

            Assert(log.Errors.Count == 0);

            // EXPR_VALUE is included in IsBeginLexicalState (discriminates left bracket kind):
            tokens = GetRubyTokens(log, "x = 1 ? [] : []");
            Assert(tokens.ToArray().ValueEquals(new[] {
		        Tokens.Identifier,
		        Tokens.Assignment,
		        Tokens.Integer,
		        Tokens.QuestionMark,
		        Tokens.LeftBracket,
		        Tokens.RightBracket,
		        Tokens.Colon,
		        Tokens.LeftBracket,
		        Tokens.RightBracket,
		        Tokens.EndOfFile,
            }));

            Assert(log.Errors.Count == 0);

            // Default block parameter is different from default method parameter.
            // Block parameter doesn't allow using binary expressions etc. due to ambiguity with binary OR operator.
            tokens = GetRubyTokens(log, "lambda {|x=1|}");
            Assert(tokens.ToArray().ValueEquals(new[] {
                Tokens.Identifier,
                Tokens.LeftBlockBrace,
                Tokens.Pipe,
                Tokens.Identifier,
                Tokens.Assignment,
                Tokens.Integer,
                Tokens.Pipe,
                Tokens.RightBrace,
                Tokens.EndOfFile,
            }));

            Assert(log.Errors.Count == 0);

            tokens = GetRubyTokens(log, "lambda { ->(){} }");
            Assert(tokens.ToArray().ValueEquals(new[] {
                Tokens.Identifier,
		        Tokens.LeftBlockBrace,
		        Tokens.Lambda,
		        Tokens.LeftParenthesis,
		        Tokens.RightParenthesis,	
		        Tokens.LeftLambdaBrace,
		        Tokens.RightBrace,
		        Tokens.RightBrace,
		        Tokens.EndOfFile,
            }));

            Assert(log.Errors.Count == 0);

            tokens = GetRubyTokens(log, "\"#{->{ }}\"\n-> do\nend");

            Assert(tokens.ToArray().ValueEquals(new[] {
                Tokens.StringBegin,
		        Tokens.StringEmbeddedCodeBegin,
		        Tokens.Lambda,
		        Tokens.LeftLambdaBrace,	
		        Tokens.RightBrace,
		        Tokens.StringEmbeddedCodeEnd,
                Tokens.StringEnd,
                Tokens.NewLine,
                Tokens.Lambda,
                Tokens.LambdaDo,
                Tokens.NewLine,
                Tokens.End,
		        Tokens.EndOfFile,
            }));

            Assert(log.Errors.Count == 0);
        }