Esempio n. 1
0
        public static bool Parse(SyntaxContext context, int position)
        {
            var list     = context.list;
            var offset   = 0;
            var index    = position;
            var count    = 0;
            var isMissed = false;

            if (!ParserHelper.IsOperator(list[index], "-"))
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            while (ParenParser.Parse(context, index))
            {
                ;
            }
            while (TableIParser.Parse(context, index))
            {
                ;
            }
            while (TableSParser.Parse(context, index))
            {
                ;
            }
            while (ListParser.Parse(context, index))
            {
                ;
            }
            while (PropertyParser.Parse(context, index))
            {
                ;
            }
            while (IndexParser.Parse(context, index))
            {
                ;
            }
            while (CallParser.Parse(context, index))
            {
                ;
            }
            if (!list[index].isRightValue)
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            context.Insert(position, ExpressionCreator.CreateNegate(list, position, offset));
            context.Remove(position + 1, offset);
            return(true);
        }
Esempio n. 2
0
        public void IndexPageTest()
        {
            // arrange
            const string expectedEmail      = "*****@*****.**";
            const bool   expectedIsLoggedin = true;
            var          expectedWeeks      = new Dictionary <int, WeekItem>
            {
                { 0, new WeekItem(7, 2015) },
                { 1, new WeekItem(8, 2015) },
                { 2, new WeekItem(9, 2015) },
            };

            // act
            var htmlContent  = GetFileContent("index.html");
            var indexParser  = new IndexParser(htmlContent);
            var indexContent = indexParser.Parse();

            // assert
            Assert.That(indexContent, Is.Not.Null);
            Assert.That(indexContent.Email, Is.EqualTo(expectedEmail));
            Assert.That(indexContent.IsLoggedin, Is.EqualTo(expectedIsLoggedin));
            Assert.That(indexContent.Weeks.Count, Is.EqualTo(expectedWeeks.Count));

            foreach (var item in indexContent.Weeks)
            {
                Assert.That(expectedWeeks.ContainsKey(item.Key), Is.True);
                Assert.That(expectedWeeks[item.Key].Year, Is.EqualTo(item.Value.Year));
                Assert.That(expectedWeeks[item.Key].WeekNr, Is.EqualTo(item.Value.WeekNr));
            }
        }
Esempio n. 3
0
 public void ParseTest()
 {
     using (FileStream stream = File.Open("../../../testfiles/testdir.czip", FileMode.Open))
     {
         BinaryReader bstream = new BinaryReader(stream);
         ZipDirectory zdir    = IndexParser.Parse(bstream);
         if (!zdir.DeepEquals(testdir))
         {
             Assert.Fail();
         }
     }
 }
Esempio n. 4
0
        public async Task IndexPageTest()
        {
            // arrange
            var htmlContent = GetFileContent("index.txt");
            var indexParser = new IndexParser(NullLogger.Instance);

            // act
            IndexContent indexContent = indexParser.Parse(htmlContent);

            // assert
            await Verifier.Verify(indexContent);
        }
Esempio n. 5
0
        public static bool Parse(SyntaxContext context, int position)
        {
            var list     = context.list;
            var offset   = 0;
            var index    = position;
            var count    = 0;
            var isMissed = false;

            while (PropertyParser.Parse(context, index))
            {
                ;
            }
            while (IndexParser.Parse(context, index))
            {
                ;
            }
            if (!list[index].isLeftValue)
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (!ParserHelper.IsOperator(list[index], ","))
            {
                isMissed         = true;
                context.isMissed = true;
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (isMissed)
            {
                offset -= 1;
            }
            context.Insert(position, ExpressionCreator.CreateLeftEx(list, position, offset));
            context.Remove(position + 1, offset);
            if (isMissed)
            {
                return(false);
            }
            return(true);
        }
Esempio n. 6
0
        public static bool Parse(SyntaxContext context, int position)
        {
            var list     = context.list;
            var offset   = 0;
            var index    = position;
            var count    = 0;
            var isMissed = false;

            if (!ParserHelper.IsOperator(list[index], "["))
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            while (FunctionAParser.Parse(context, index))
            {
                ;
            }
            while (ParenParser.Parse(context, index))
            {
                ;
            }
            while (TableIParser.Parse(context, index))
            {
                ;
            }
            while (TableSParser.Parse(context, index))
            {
                ;
            }
            while (ListParser.Parse(context, index))
            {
                ;
            }
            while (PropertyParser.Parse(context, index))
            {
                ;
            }
            while (IndexParser.Parse(context, index))
            {
                ;
            }
            while (CallParser.Parse(context, index))
            {
                ;
            }
            while (NotParser.Parse(context, index))
            {
                ;
            }
            while (LengthParser.Parse(context, index))
            {
                ;
            }
            while (NegateParser.Parse(context, index))
            {
                ;
            }
            while (PowerParser.Parse(context, index))
            {
                ;
            }
            while (MultiplyParser.Parse(context, index))
            {
                ;
            }
            while (DivisionParser.Parse(context, index))
            {
                ;
            }
            while (ModParser.Parse(context, index))
            {
                ;
            }
            while (AddParser.Parse(context, index))
            {
                ;
            }
            while (SubtractParser.Parse(context, index))
            {
                ;
            }
            while (ConcatParser.Parse(context, index))
            {
                ;
            }
            while (LessParser.Parse(context, index))
            {
                ;
            }
            while (GreaterParser.Parse(context, index))
            {
                ;
            }
            while (LessEqualParser.Parse(context, index))
            {
                ;
            }
            while (GreaterEqualParser.Parse(context, index))
            {
                ;
            }
            while (EqualParser.Parse(context, index))
            {
                ;
            }
            while (NotEqualParser.Parse(context, index))
            {
                ;
            }
            while (AndParser.Parse(context, index))
            {
                ;
            }
            while (OrParser.Parse(context, index))
            {
                ;
            }
            if (!list[index].isRightValue)
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (!ParserHelper.IsOperator(list[index], "]"))
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (!ParserHelper.IsOperator(list[index], "="))
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            while (FunctionAParser.Parse(context, index))
            {
                ;
            }
            while (ParenParser.Parse(context, index))
            {
                ;
            }
            while (TableIParser.Parse(context, index))
            {
                ;
            }
            while (TableSParser.Parse(context, index))
            {
                ;
            }
            while (ListParser.Parse(context, index))
            {
                ;
            }
            while (PropertyParser.Parse(context, index))
            {
                ;
            }
            while (IndexParser.Parse(context, index))
            {
                ;
            }
            while (CallParser.Parse(context, index))
            {
                ;
            }
            while (NotParser.Parse(context, index))
            {
                ;
            }
            while (LengthParser.Parse(context, index))
            {
                ;
            }
            while (NegateParser.Parse(context, index))
            {
                ;
            }
            while (PowerParser.Parse(context, index))
            {
                ;
            }
            while (MultiplyParser.Parse(context, index))
            {
                ;
            }
            while (DivisionParser.Parse(context, index))
            {
                ;
            }
            while (ModParser.Parse(context, index))
            {
                ;
            }
            while (AddParser.Parse(context, index))
            {
                ;
            }
            while (SubtractParser.Parse(context, index))
            {
                ;
            }
            while (ConcatParser.Parse(context, index))
            {
                ;
            }
            while (LessParser.Parse(context, index))
            {
                ;
            }
            while (GreaterParser.Parse(context, index))
            {
                ;
            }
            while (LessEqualParser.Parse(context, index))
            {
                ;
            }
            while (GreaterEqualParser.Parse(context, index))
            {
                ;
            }
            while (EqualParser.Parse(context, index))
            {
                ;
            }
            while (NotEqualParser.Parse(context, index))
            {
                ;
            }
            while (AndParser.Parse(context, index))
            {
                ;
            }
            while (OrParser.Parse(context, index))
            {
                ;
            }
            if (!list[index].isRightValue)
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (!ParserHelper.IsOperator(list[index], ","))
            {
                isMissed         = true;
                context.isMissed = true;
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (isMissed)
            {
                offset -= 1;
            }
            context.Insert(position, ExpressionCreator.CreateKV2(list, position, offset));
            context.Remove(position + 1, offset);
            if (isMissed)
            {
                return(false);
            }
            return(true);
        }
Esempio n. 7
0
        public static bool Parse(SyntaxContext context, int position)
        {
            var list     = context.list;
            var offset   = 0;
            var index    = position;
            var count    = 0;
            var isMissed = false;

            if (!ParserHelper.IsKeyword(list[index], "if"))
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            while (FunctionAParser.Parse(context, index))
            {
                ;
            }
            while (ParenParser.Parse(context, index))
            {
                ;
            }
            while (TableIParser.Parse(context, index))
            {
                ;
            }
            while (TableSParser.Parse(context, index))
            {
                ;
            }
            while (ListParser.Parse(context, index))
            {
                ;
            }
            while (PropertyParser.Parse(context, index))
            {
                ;
            }
            while (IndexParser.Parse(context, index))
            {
                ;
            }
            while (CallParser.Parse(context, index))
            {
                ;
            }
            while (NotParser.Parse(context, index))
            {
                ;
            }
            while (LengthParser.Parse(context, index))
            {
                ;
            }
            while (NegateParser.Parse(context, index))
            {
                ;
            }
            while (PowerParser.Parse(context, index))
            {
                ;
            }
            while (MultiplyParser.Parse(context, index))
            {
                ;
            }
            while (DivisionParser.Parse(context, index))
            {
                ;
            }
            while (ModParser.Parse(context, index))
            {
                ;
            }
            while (AddParser.Parse(context, index))
            {
                ;
            }
            while (SubtractParser.Parse(context, index))
            {
                ;
            }
            while (ConcatParser.Parse(context, index))
            {
                ;
            }
            while (LessParser.Parse(context, index))
            {
                ;
            }
            while (GreaterParser.Parse(context, index))
            {
                ;
            }
            while (LessEqualParser.Parse(context, index))
            {
                ;
            }
            while (GreaterEqualParser.Parse(context, index))
            {
                ;
            }
            while (EqualParser.Parse(context, index))
            {
                ;
            }
            while (NotEqualParser.Parse(context, index))
            {
                ;
            }
            while (AndParser.Parse(context, index))
            {
                ;
            }
            while (OrParser.Parse(context, index))
            {
                ;
            }
            if (!list[index].isRightValue)
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (!ParserHelper.IsKeyword(list[index], "then"))
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            while (ModuleParser.Parse(context, index))
            {
                ;
            }
            if (list[index].type != Expression.Type.Module)
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (!ParserHelper.IsKeyword(list[index], "else"))
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            while (ModuleParser.Parse(context, index))
            {
                ;
            }
            if (list[index].type != Expression.Type.Module)
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            if (!ParserHelper.IsKeyword(list[index], "end"))
            {
                return(false);
            }
            else
            {
                // ignored
            }
            offset += 1;
            index   = position + offset;
            context.Insert(position, ExpressionCreator.CreateIfElse(list, position, offset));
            context.Remove(position + 1, offset);
            return(true);
        }