API tools faq
paste
Advertisement
szymski

Untitled

szymski
Aug 14th, 2016
185
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 24.88 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Text;
  3. using System.Collections.Generic;
  4. using LuaAdv.Compiler;
  5. using LuaAdv.Compiler.Lexer;
  6. using LuaAdv.Compiler.Nodes;
  7. using LuaAdv.Compiler.Nodes.Expressions;
  8. using LuaAdv.Compiler.Nodes.Expressions.BasicTypes;
  9. using LuaAdv.Compiler.Nodes.Expressions.Comparison;
  10. using LuaAdv.Compiler.Nodes.Expressions.Conditional;
  11. using LuaAdv.Compiler.Nodes.Expressions.Logical;
  12. using LuaAdv.Compiler.Nodes.Expressions.Unary;
  13. using LuaAdv.Compiler.Nodes.Expressions.Unary.Post;
  14. using LuaAdv.Compiler.Nodes.Expressions.Unary.Pre;
  15. using LuaAdv.Compiler.Nodes.Math;
  16. using LuaAdv.Compiler.Nodes.Statements;
  17. using LuaAdv.Compiler.SyntaxAnalyzer;
  18. using NUnit.Framework;
  19. using Is = LuaAdv.Compiler.Nodes.Expressions.Comparison.Is;
  20.  
  21. namespace LuaAdvTests
  22. {
  23.     [TestFixture]
  24.     public class SyntaxAnalyzerTests
  25.     {
  26.         public Node Compile(string code)
  27.         {
  28.             Lexer lexer = new Lexer(code);
  29.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output);
  30.  
  31.             return analyzer.OutputNode;
  32.         }
  33.  
  34.         [Test]
  35.         public void test_analyze_nothing()
  36.         {
  37.             Lexer lexer = new Lexer("");
  38.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output);
  39.  
  40.             var output = analyzer.OutputNode;
  41.  
  42.             Assert.IsInstanceOf<Sequence>(output);
  43.         }
  44.  
  45.         [Test]
  46.         public void test_analyze_ifs()
  47.         {
  48.             Lexer lexer = new Lexer("if(true) { } else if(false) { } else { }");
  49.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output);
  50.  
  51.             var output = analyzer.OutputNode;
  52.  
  53.             Assert.IsInstanceOf<Sequence>(output);
  54.             Assert.IsInstanceOf<If>(output.Children[0]);
  55.             Assert.IsInstanceOf<Bool>(output.Children[0][0]);
  56.             Assert.IsInstanceOf<Sequence>(output.Children[0][1]);
  57.             Assert.IsInstanceOf<Bool>(output.Children[0][2]);
  58.             Assert.IsInstanceOf<Sequence>(output.Children[0][3]);
  59.             Assert.IsInstanceOf<Sequence>(output.Children[0][5]);
  60.         }
  61.  
  62.         [Test]
  63.         public void test_analyze_for_loop()
  64.         {
  65.             Lexer lexer = new Lexer("for(;false;) { }");
  66.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output);
  67.  
  68.             var output = analyzer.OutputNode;
  69.  
  70.             Assert.IsInstanceOf<Sequence>(output);
  71.             Assert.IsInstanceOf<For>(output.Children[0]);
  72.             Assert.IsInstanceOf<Bool>(output.Children[0][1]);
  73.         }
  74.  
  75.         [Test]
  76.         public void test_expression_list()
  77.         {
  78.             Lexer lexer = new Lexer("return true, false, true");
  79.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  80.  
  81.             analyzer.AcceptKeyword("return");
  82.  
  83.             var expList = analyzer.ExpressionList();
  84.             Assert.AreEqual(3, expList.Count);
  85.         }
  86.  
  87.         [Test]
  88.         public void test_expression_list_error()
  89.         {
  90.             Assert.Throws<SyntaxAnalyzerException>(() =>
  91.             {
  92.                 Lexer lexer = new Lexer("return true, false,");
  93.                 SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  94.  
  95.                 analyzer.AcceptKeyword("return");
  96.  
  97.                 analyzer.ExpressionList();
  98.             });
  99.         }
  100.  
  101.         [Test]
  102.         public void test_expression_list_empty()
  103.         {
  104.             Lexer lexer = new Lexer("return ");
  105.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  106.  
  107.             analyzer.AcceptKeyword("return");
  108.  
  109.             var expList = analyzer.ExpressionList();
  110.             Assert.AreEqual(0, expList.Count);
  111.         }
  112.  
  113.         [Test]
  114.         public void test_function_param_list()
  115.         {
  116.             Lexer lexer = new Lexer("param1, param2 = true, param3");
  117.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  118.  
  119.             var paramList = analyzer.FunctionParameterList();
  120.             Assert.AreEqual(3, paramList.Count);
  121.  
  122.             Assert.AreEqual("param1", paramList[0].Item2);
  123.             Assert.AreEqual("param2", paramList[1].Item2);
  124.             Assert.IsInstanceOf<Bool>(paramList[1].Item3);
  125.             Assert.AreEqual("param3", paramList[2].Item2);
  126.         }
  127.  
  128.         [Test]
  129.         public void test_function_param_error()
  130.         {
  131.             Assert.Throws<SyntaxAnalyzerException>(() =>
  132.             {
  133.                 Lexer lexer = new Lexer("param1, param2 = , param3");
  134.                 SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  135.  
  136.                 analyzer.FunctionParameterList();
  137.             });
  138.         }
  139.  
  140.         [Test]
  141.         public void test_function_param_error_empty()
  142.         {
  143.             Lexer lexer = new Lexer("");
  144.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  145.  
  146.             var paramList = analyzer.FunctionParameterList();
  147.             Assert.AreEqual(0, paramList.Count);
  148.         }
  149.  
  150.         [Test]
  151.         public void test_functions()
  152.         {
  153.             Lexer lexer = new Lexer("function Derp.Asd(param1 = true, param2) { }\nlocal function Func() { }");
  154.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output);
  155.  
  156.             var output = analyzer.OutputNode;
  157.  
  158.             Assert.IsInstanceOf<StatementFunctionDeclaration>(output[0]);
  159.             var func1 = (StatementFunctionDeclaration)output[0];
  160.             Assert.AreEqual(2, func1.parameterList.Count);
  161.  
  162.             Assert.IsInstanceOf<StatementFunctionDeclaration>(output[1]);
  163.             var func2 = (StatementFunctionDeclaration)output[1];
  164.             Assert.AreEqual(0, func2.parameterList.Count);
  165.             Assert.IsTrue(func2.local);
  166.         }
  167.  
  168.         [Test]
  169.         public void test_function_errors()
  170.         {
  171.             Assert.Throws<SyntaxAnalyzerException>(() =>
  172.             {
  173.                 Compile("function Test( { }");
  174.             });
  175.  
  176.             Assert.Throws<SyntaxAnalyzerException>(() =>
  177.             {
  178.                 Compile("function () {}");
  179.             });
  180.  
  181.             Assert.Throws<SyntaxAnalyzerException>(() =>
  182.             {
  183.                 Compile("function (return) {}");
  184.             });
  185.  
  186.             Assert.Throws<SyntaxAnalyzerException>(() =>
  187.             {
  188.                 Compile("function Test()");
  189.             });
  190.         }
  191.  
  192.         [Test]
  193.         public void test_variable_name_list()
  194.         {
  195.             Lexer lexer = new Lexer("rzopa, (rzopa).nierzopa, func().func2().a, rzopa2[true][false], rzopa3.y.z");
  196.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  197.  
  198.             var varNameList = analyzer.NamedVariableList();
  199.             Assert.AreEqual(5, varNameList.Count);
  200.         }
  201.  
  202.         [Test]
  203.         public void test_identifier_list()
  204.         {
  205.             Lexer lexer = new Lexer("a, b, abc");
  206.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  207.  
  208.             var identList = analyzer.IdentifierList();
  209.             Assert.AreEqual(3, identList.Count);
  210.  
  211.             Assert.AreEqual("a", identList[0].Item2);
  212.             Assert.AreEqual("b", identList[1].Item2);
  213.             Assert.AreEqual("abc", identList[2].Item2);
  214.         }
  215.  
  216.         [Test]
  217.         public void test_identifier_error()
  218.         {
  219.             Assert.Throws<SyntaxAnalyzerException>(() =>
  220.             {
  221.                 Lexer lexer = new Lexer("a, b,");
  222.                 SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  223.  
  224.                 analyzer.IdentifierList();
  225.             });
  226.         }
  227.  
  228.         [Test]
  229.         public void test_local_variable_declaration()
  230.         {
  231.             var output = Compile("var oneVar");
  232.  
  233.             Assert.IsInstanceOf<LocalVariablesDeclaration>(output[0]);
  234.             Assert.AreEqual("oneVar", (output[0] as LocalVariablesDeclaration).variables[0].Item2);
  235.  
  236.             output = Compile("var var1, secVar, thirdVar = true, false, true");
  237.  
  238.             Assert.IsInstanceOf<LocalVariablesDeclaration>(output[0]);
  239.             Assert.AreEqual("var1", (output[0] as LocalVariablesDeclaration).variables[0].Item2);
  240.             Assert.AreEqual("secVar", (output[0] as LocalVariablesDeclaration).variables[1].Item2);
  241.             Assert.AreEqual("thirdVar", (output[0] as LocalVariablesDeclaration).variables[2].Item2);
  242.             Assert.IsInstanceOf<Bool>((output[0] as LocalVariablesDeclaration).values[0]);
  243.             Assert.IsInstanceOf<Bool>((output[0] as LocalVariablesDeclaration).values[1]);
  244.             Assert.IsInstanceOf<Bool>((output[0] as LocalVariablesDeclaration).values[2]);
  245.  
  246.             output = Compile("var var1, secVar, thirdVar = true");
  247.  
  248.             Assert.IsInstanceOf<LocalVariablesDeclaration>(output[0]);
  249.             Assert.AreEqual("var1", (output[0] as LocalVariablesDeclaration).variables[0].Item2);
  250.             Assert.AreEqual("secVar", (output[0] as LocalVariablesDeclaration).variables[1].Item2);
  251.             Assert.AreEqual("thirdVar", (output[0] as LocalVariablesDeclaration).variables[2].Item2);
  252.             Assert.IsInstanceOf<Bool>((output[0] as LocalVariablesDeclaration).values[0]);
  253.         }
  254.  
  255.         [Test]
  256.         public void test_local_variable_declaration_errors()
  257.         {
  258.             Assert.Throws<SyntaxAnalyzerException>(() =>
  259.             {
  260.                 Compile("var");
  261.             });
  262.  
  263.             Assert.Throws<SyntaxAnalyzerException>(() =>
  264.             {
  265.                 Compile("var dupa.rzopa");
  266.             });
  267.  
  268.             Assert.Throws<SyntaxAnalyzerException>(() =>
  269.             {
  270.                 Compile("var asd, asd,");
  271.             });
  272.  
  273.             Assert.Throws<SyntaxAnalyzerException>(() =>
  274.             {
  275.                 Compile("var asd1, asd2 = true, true, false, false");
  276.             });
  277.  
  278.             Assert.Throws<SyntaxAnalyzerException>(() =>
  279.             {
  280.                 Compile("var asd1, asd2 = ");
  281.             });
  282.         }
  283.  
  284.         [Test]
  285.         public void test_lambda_functions()
  286.         {
  287.             Lexer lexer = new Lexer("function Derp(asd) => 123");
  288.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  289.  
  290.             Statement node;
  291.  
  292.             node = analyzer.Statement();
  293.             Assert.IsInstanceOf<StatementLambdaFunctionDeclaration>(node);
  294.         }
  295.  
  296.         [Test]
  297.         public void test_methods()
  298.         {
  299.             Lexer lexer = new Lexer("function lol:derp() { } " +
  300.                                     "function asdf.asd:lol() { } " +
  301.                                     "function this[asd].isa:derp():AFunc() { } " +
  302.                                     "function lol:derp() => 5" +
  303.                                     "local function derp:asd() { }");
  304.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  305.  
  306.             Statement node;
  307.  
  308.             node = analyzer.Statement();
  309.             Assert.IsInstanceOf<StatementMethodDeclaration>(node);
  310.  
  311.             node = analyzer.Statement();
  312.             Assert.IsInstanceOf<StatementMethodDeclaration>(node);
  313.  
  314.             node = analyzer.Statement();
  315.             Assert.IsInstanceOf<StatementMethodDeclaration>(node);
  316.  
  317.             node = analyzer.Statement();
  318.             Assert.IsInstanceOf<StatementLambdaMethodDeclaration>(node);
  319.  
  320.             Assert.Throws<SyntaxAnalyzerException>(() =>
  321.             {
  322.                 analyzer.Statement();
  323.             });
  324.         }
  325.  
  326.         [Test]
  327.         public void test_global_variables_declaration()
  328.         {
  329.             Lexer lexer = new Lexer("a = 5 " +
  330.                                     "a, b, c = 1, 2, 3 " +
  331.                                     "table.a[123], derp = 1, 2 " +
  332.                                     "a = 1, 2 " +
  333.                                     "func() = 123");
  334.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  335.  
  336.             Statement node;
  337.  
  338.             node = analyzer.Statement();
  339.             Assert.IsInstanceOf<GlobalVariablesDeclaration>(node);
  340.  
  341.             node = analyzer.Statement();
  342.             Assert.IsInstanceOf<GlobalVariablesDeclaration>(node);
  343.  
  344.             node = analyzer.Statement();
  345.             Assert.IsInstanceOf<GlobalVariablesDeclaration>(node);
  346.  
  347.             Assert.Throws<SyntaxAnalyzerException>(() =>
  348.             {
  349.                 analyzer.Statement();
  350.             });
  351.  
  352.             Assert.Throws<SyntaxAnalyzerException>(() =>
  353.             {
  354.                 analyzer.Statement();
  355.             });
  356.         }
  357.     }
  358.  
  359.     [TestFixture]
  360.     public class SyntaxAnalyzerTestsExpressions
  361.     {
  362.         public Node Compile(string code)
  363.         {
  364.             Lexer lexer = new Lexer(code);
  365.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output);
  366.  
  367.             return analyzer.OutputNode;
  368.         }
  369.  
  370.         [Test]
  371.         public void test_grouped_equation()
  372.         {
  373.             Lexer lexer = new Lexer("((true))");
  374.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  375.  
  376.             var output = analyzer.Expression();
  377.  
  378.             Assert.IsInstanceOf<GroupedEquation>(output);
  379.             Assert.IsInstanceOf<GroupedEquation>(output[0]);
  380.             Assert.IsInstanceOf<Bool>(output[0][0]);
  381.         }
  382.  
  383.         [Test]
  384.         public void test_basic_types()
  385.         {
  386.             Lexer lexer = new Lexer("true false 123 12.50 \"DERP\" this null");
  387.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  388.  
  389.             Assert.IsInstanceOf<Bool>(analyzer.Expression());
  390.             Assert.IsInstanceOf<Bool>(analyzer.Expression());
  391.             Assert.IsInstanceOf<Number>(analyzer.Expression());
  392.             Assert.IsInstanceOf<Number>(analyzer.Expression());
  393.             Assert.IsInstanceOf<StringType>(analyzer.Expression());
  394.             Assert.IsInstanceOf<This>(analyzer.Expression());
  395.             Assert.IsInstanceOf<Null>(analyzer.Expression());
  396.         }
  397.  
  398.         [Test]
  399.         public void test_variables()
  400.         {
  401.             Lexer lexer = new Lexer("var1 var2");
  402.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  403.  
  404.             Assert.IsInstanceOf<Variable>(analyzer.Expression());
  405.             Assert.IsInstanceOf<Variable>(analyzer.Expression());
  406.         }
  407.  
  408.         [Test]
  409.         public void test_table_index()
  410.         {
  411.             Lexer lexer = new Lexer("var1.somevar var2.somevar.another");
  412.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  413.  
  414.             Assert.IsInstanceOf<TableDotIndex>(analyzer.Expression());
  415.             Assert.IsInstanceOf<TableDotIndex>(analyzer.Expression()[0]);
  416.  
  417.             lexer = new Lexer("var1[1] var2[\"derp\"][lol] var3.lol[5]");
  418.             analyzer = new SyntaxAnalyzer(lexer.Output, true);
  419.  
  420.             Assert.IsInstanceOf<TableIndex>(analyzer.Expression());
  421.             Assert.IsInstanceOf<TableIndex>(analyzer.Expression()[0]);
  422.             Assert.IsInstanceOf<TableDotIndex>(analyzer.Expression()[0]);
  423.         }
  424.  
  425.         [Test]
  426.         public void test_function_call()
  427.         {
  428.             Lexer lexer = new Lexer("func(123, 123) derp.func() derp()(5)(123)");
  429.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  430.  
  431.             Assert.IsInstanceOf<FunctionCall>(analyzer.Expression());
  432.             Assert.IsInstanceOf<FunctionCall>(analyzer.Expression());
  433.             Assert.IsInstanceOf<FunctionCall>(analyzer.Expression()[0][0]);
  434.         }
  435.  
  436.         [Test]
  437.         public void test_method_call()
  438.         {
  439.             Lexer lexer = new Lexer("dupa:Func(123, 123) a:a(5):a(5)");
  440.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  441.  
  442.             Assert.IsInstanceOf<MethodCall>(analyzer.Expression());
  443.             Assert.IsInstanceOf<MethodCall>(analyzer.Expression()[0]);
  444.         }
  445.  
  446.         [Test]
  447.         public void test_conditional()
  448.         {
  449.             Lexer lexer = new Lexer("true || false true && false || true false || false || false");
  450.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  451.  
  452.             Expression exp;
  453.  
  454.             exp = analyzer.Expression();
  455.             Assert.IsInstanceOf<ConditionalOr>(exp);
  456.  
  457.             exp = analyzer.Expression();
  458.             Assert.IsInstanceOf<ConditionalOr>(exp);
  459.             Assert.IsInstanceOf<ConditionalAnd>(exp[0]);
  460.  
  461.             exp = analyzer.Expression();
  462.             Assert.IsInstanceOf<ConditionalOr>(exp);
  463.             Assert.IsInstanceOf<ConditionalOr>(exp[1]);
  464.         }
  465.  
  466.         [Test]
  467.         public void test_logical()
  468.         {
  469.             Lexer lexer = new Lexer("5 ^ 7 " +
  470.                                     "2 | 3 " +
  471.                                     "a & b " +
  472.                                     "123 | 123 ^ lol ^ lol");
  473.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  474.  
  475.             Expression exp;
  476.  
  477.             exp = analyzer.Expression();
  478.             Assert.IsInstanceOf<LogicalXor>(exp);
  479.  
  480.             exp = analyzer.Expression();
  481.             Assert.IsInstanceOf<LogicalOr>(exp);
  482.  
  483.             exp = analyzer.Expression();
  484.             Assert.IsInstanceOf<LogicalAnd>(exp);
  485.  
  486.             exp = analyzer.Expression();
  487.             Assert.IsInstanceOf<LogicalOr>(exp);
  488.             Assert.IsInstanceOf<LogicalXor>(exp[1]);
  489.             Assert.IsInstanceOf<LogicalXor>(exp[1][1]);
  490.         }
  491.  
  492.         [Test]
  493.         public void test_comparison_equals_notequals()
  494.         {
  495.             Lexer lexer = new Lexer("5 == 5 " +
  496.                                     "5 == derp != false " +
  497.                                     "5 != 2 ^ 8");
  498.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  499.  
  500.             Expression exp;
  501.  
  502.             exp = analyzer.Expression();
  503.             Assert.IsInstanceOf<Equals>(exp);
  504.  
  505.             exp = analyzer.Expression();
  506.             Assert.IsInstanceOf<Equals>(exp);
  507.             Assert.IsInstanceOf<NotEquals>(exp[1]);
  508.             Assert.IsInstanceOf<Variable>(exp[1][0]);
  509.             Assert.IsInstanceOf<Bool>(exp[1][1]);
  510.  
  511.             exp = analyzer.Expression();
  512.             Assert.IsInstanceOf<LogicalXor>(exp);
  513.             Assert.IsInstanceOf<NotEquals>(exp[0]);
  514.         }
  515.  
  516.         [Test]
  517.         public void test_comparison_less_greater_is()
  518.         {
  519.             Lexer lexer = new Lexer("5 < 5 " +
  520.                                     "asd > asdf " +
  521.                                     "lol <= derp " +
  522.                                     "lol >= derp " +
  523.                                     "something is number");
  524.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  525.  
  526.             Expression exp;
  527.  
  528.             exp = analyzer.Expression();
  529.             Assert.IsInstanceOf<Less>(exp);
  530.  
  531.             exp = analyzer.Expression();
  532.             Assert.IsInstanceOf<Greater>(exp);
  533.  
  534.             exp = analyzer.Expression();
  535.             Assert.IsInstanceOf<LessOrEqual>(exp);
  536.  
  537.             exp = analyzer.Expression();
  538.             Assert.IsInstanceOf<GreaterOrEqual>(exp);
  539.  
  540.             exp = analyzer.Expression();
  541.             Assert.IsInstanceOf<Is>(exp);
  542.         }
  543.  
  544.         [Test]
  545.         public void test_shift()
  546.         {
  547.             Lexer lexer = new Lexer("10 >> 2 " +
  548.                                     "20 << 3 " +
  549.                                     "5 >> 5 >> 2 " +
  550.                                     "10 << 5 >> 2");
  551.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  552.  
  553.             Expression exp;
  554.  
  555.             exp = analyzer.Expression();
  556.             Assert.IsInstanceOf<ShiftRight>(exp);
  557.  
  558.             exp = analyzer.Expression();
  559.             Assert.IsInstanceOf<ShiftLeft>(exp);
  560.  
  561.             exp = analyzer.Expression();
  562.             Assert.IsInstanceOf<ShiftRight>(exp);
  563.             Assert.IsInstanceOf<ShiftRight>(exp[1]);
  564.  
  565.             exp = analyzer.Expression();
  566.             Assert.IsInstanceOf<ShiftLeft>(exp);
  567.             Assert.IsInstanceOf<ShiftRight>(exp[1]);
  568.         }
  569.  
  570.         [Test]
  571.         public void test_math()
  572.         {
  573.             Lexer lexer = new Lexer("10 + 2 " +
  574.                                     "20 - 3 " +
  575.                                     "5 * 5 " +
  576.                                     "10 / 5 " +
  577.                                     "12 % 2 " +
  578.                                     "10 ^^ 2 " +
  579.                                     "2 + 2 * 2 " +
  580.                                     "10 + (2 / 5) - 8 ^^ 2 " +
  581.                                     "\"something\" .. derp .. 5 + 5");
  582.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  583.  
  584.             Expression exp;
  585.  
  586.             exp = analyzer.Expression();
  587.             Assert.IsInstanceOf<Add>(exp);
  588.  
  589.             exp = analyzer.Expression();
  590.             Assert.IsInstanceOf<Subtract>(exp);
  591.  
  592.             exp = analyzer.Expression();
  593.             Assert.IsInstanceOf<Multiply>(exp);
  594.  
  595.             exp = analyzer.Expression();
  596.             Assert.IsInstanceOf<Divide>(exp);
  597.  
  598.             exp = analyzer.Expression();
  599.             Assert.IsInstanceOf<Modulo>(exp);
  600.  
  601.             exp = analyzer.Expression();
  602.             Assert.IsInstanceOf<Power>(exp);
  603.  
  604.             exp = analyzer.Expression();
  605.             Assert.IsInstanceOf<Add>(exp);
  606.             Assert.IsInstanceOf<Multiply>(exp[1]);
  607.  
  608.             exp = analyzer.Expression();
  609.             Assert.IsInstanceOf<Add>(exp);
  610.             Assert.IsInstanceOf<Subtract>(exp[1]);
  611.             Assert.IsInstanceOf<GroupedEquation>(exp[1][0]);
  612.             Assert.IsInstanceOf<Power>(exp[1][1]);
  613.  
  614.             exp = analyzer.Expression();
  615.             Assert.IsInstanceOf<Concat>(exp);
  616.             Assert.IsInstanceOf<Concat>(exp[1]);
  617.             Assert.IsInstanceOf<Variable>(exp[1][0]);
  618.             Assert.IsInstanceOf<Add>(exp[1][1]);
  619.         }
  620.  
  621.         [Test]
  622.         public void test_unary()
  623.         {
  624.             Lexer lexer = new Lexer("-5 " +
  625.                                     "!false " +
  626.                                     "~10 " +
  627.                                     "2 - -2 " +
  628.                                     "++derp " +
  629.                                     "--derp " +
  630.                                     "derp++ " +
  631.                                     "derp-- " +
  632.                                     "--func().b + (derp).a++");
  633.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  634.  
  635.             Expression exp;
  636.  
  637.             exp = analyzer.Expression();
  638.             Assert.IsInstanceOf<Negative>(exp);
  639.  
  640.             exp = analyzer.Expression();
  641.             Assert.IsInstanceOf<Not>(exp);
  642.  
  643.             exp = analyzer.Expression();
  644.             Assert.IsInstanceOf<Negation>(exp);
  645.  
  646.             exp = analyzer.Expression();
  647.             Assert.IsInstanceOf<Subtract>(exp);
  648.             Assert.IsInstanceOf<Negative>(exp[1]);
  649.  
  650.             exp = analyzer.Expression();
  651.             Assert.IsInstanceOf<PreIncrement>(exp);
  652.  
  653.             exp = analyzer.Expression();
  654.             Assert.IsInstanceOf<PreDecrement>(exp);
  655.  
  656.             exp = analyzer.Expression();
  657.             Assert.IsInstanceOf<PostIncrement>(exp);
  658.  
  659.             exp = analyzer.Expression();
  660.             Assert.IsInstanceOf<PostDecrement>(exp);
  661.  
  662.             exp = analyzer.Expression();
  663.             Assert.IsInstanceOf<Add>(exp);
  664.             Assert.IsInstanceOf<PreDecrement>(exp[0]);
  665.             Assert.IsInstanceOf<PostIncrement>(exp[1]);
  666.         }
  667.  
  668.         [Test]
  669.         public void test_functions()
  670.         {
  671.             Lexer lexer = new Lexer("function() { } " +
  672.                                     "function() => 123 ");
  673.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  674.  
  675.             Expression exp;
  676.  
  677.             exp = analyzer.Expression();
  678.             Assert.IsInstanceOf<AnonymousFunction>(exp);
  679.  
  680.             exp = analyzer.Expression();
  681.             Assert.IsInstanceOf<AnonymousLambdaFunction>(exp);
  682.         }
  683.  
  684.         [Test]
  685.         public void test_single_named_variable()
  686.         {
  687.             Lexer lexer = new Lexer("derp " +
  688.                                     "derp.derp " +
  689.                                     "derp().derp " +
  690.                                     "derp[123].lol " +
  691.                                     "derp[150].derp () " +
  692.                                     "derp:GetTbl().asd ()");
  693.             SyntaxAnalyzer analyzer = new SyntaxAnalyzer(lexer.Output, true);
  694.  
  695.             Expression exp;
  696.  
  697.             exp = analyzer.NamedVariable();
  698.             Assert.IsInstanceOf<NamedVariable>(exp);
  699.  
  700.             exp = analyzer.NamedVariable();
  701.             Assert.IsInstanceOf<NamedVariable>(exp);
  702.  
  703.             exp = analyzer.NamedVariable();
  704.             Assert.IsInstanceOf<NamedVariable>(exp);
  705.  
  706.             exp = analyzer.NamedVariable();
  707.             Assert.IsInstanceOf<NamedVariable>(exp);
  708.  
  709.             exp = analyzer.NamedVariable();
  710.             Assert.IsInstanceOf<NamedVariable>(exp);
  711.  
  712.             analyzer.tokenIndex += 2;
  713.  
  714.             exp = analyzer.NamedVariable();
  715.             Assert.IsInstanceOf<NamedVariable>(exp);
  716.         }
  717.     }
  718. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!