Add Axiom Unit Tests

.gitignore

@@ -1,6 +1,7 @@
 Axiom/Axiom.Core/bin/**
 Axiom/Axiom.Core/obj/**
-Axiom/obj/**
+AxiomUnitTests/bin/**
+AxiomUnitTests/obj/**
 MarketData/MarketData/bin/**
 MarketData/MarketDataLib/obj/**
 MarketData/MarketData/obj/**

Axiom/Axiom.Core/Interpreter/CodeRunner.cs

@@ -27,10 +27,12 @@ namespace Axiom.Interpreter
       symbolTable=new SymbolTable();
 			IsInError=false;
     }
+
     ~CodeRunner()
     {
       Dispose(false);
     }
+
     public void Dispose()
     {
       if (!disposed)
@@ -39,6 +41,7 @@ namespace Axiom.Interpreter
         GC.SuppressFinalize(this);
       }
     }
+
     protected virtual void Dispose(bool disposing)
     {
       if(disposing)
@@ -51,22 +54,28 @@ namespace Axiom.Interpreter
       }
       disposed = true;
     }
+
     public int ParseSymbolsCount
     {
       get{return parseSymbolCount;}
     }
+
     public String LastMessage{ get; private set;}
+
 		public bool IsInError { get; private set;}
+
     public bool ScanStrict
     {
       get{return scanStrict;}
       set{scanStrict=value;}
     }
+
     public bool ParseStrict
     {
       get{return parseStrict;}
       set{parseStrict=value;}
     }
+
     public bool Trace
     {
       get {return trace;}
@@ -77,6 +86,7 @@ namespace Axiom.Interpreter
       get { return useCache; }
       set { useCache = value; }
     }
+
     public String GetValue(String name)
     {
       if (!symbolTable.ContainsKey(name)) return "null";
@@ -85,6 +95,7 @@ namespace Axiom.Interpreter
       if (null == genericData || genericData.IsNull()) return "null";
       return genericData.Get<String>();
     }
+
     public T GetValue<T>(String name)
     {
       if(!symbolTable.ContainsKey(name)) return default(T);
@@ -93,20 +104,24 @@ namespace Axiom.Interpreter
       if(null==genericData||genericData.IsNull()) return default(T);
       return genericData.Get<T>();
     }
+
     public SymbolTable SymbolTable
     {
       get {return symbolTable;}
     }
+
     public void Reset()
     {
       if (null == symbolTable) return;
       symbolTable.Reset();
     }
+
     public bool Execute(DataTable dataTable, int row, String expression)
     {
       Reset();
       return ExecuteExpressionOnRow(dataTable, row, expression);
     }
+
     private bool ExecuteExpressionOnRow(DataTable dataTable, int row, String expression)
     {
       symbolTable.AddUserSymbols(dataTable);                                         // add symbol names from the data table columns
@@ -121,6 +136,13 @@ namespace Axiom.Interpreter
       }
       return true;
     }
+
+    /// <summary>
+    ///  Execute - Executes the given expression.  You can then use the helper methods.
+    ///  GetValue(String), GetValue<T>(String) to retrieve resulting variables from the symbolTable  
+    /// </summary>
+    /// <param name="expression"></param>
+    /// <returns></returns>
     public bool Execute(String expression)
     {
       BinaryReader binaryReader = null;
@@ -142,7 +164,7 @@ namespace Axiom.Interpreter
         {
           LastMessage="Failed to scan the input document, possible invalid character sequence.";
 					IsInError=true;
-          MDTrace.WriteLine(LogLevel.DEBUG, LastMessage);
+          MDTrace.WriteLine(LogLevel.DEBUG,LastMessage);
           return false;
         }
         binaryWriter.BaseStream.Seek(0, SeekOrigin.Begin);
@@ -156,7 +178,7 @@ namespace Axiom.Interpreter
         {
           LastMessage=String.Format("Failed to parse the input, {0} at {1}", parser.LastMessage, parser.LastLineNumber);
 					IsInError=true;
-          MDTrace.WriteLine(LogLevel.DEBUG, LastMessage);
+          MDTrace.WriteLine(LogLevel.DEBUG,LastMessage);
           return false;
         }
         parserWriter.BaseStream.Seek(0, SeekOrigin.Begin);            // SEEK TO THE BEGINNING OF THE CODE
@@ -168,7 +190,7 @@ namespace Axiom.Interpreter
         {
           LastMessage=String.Format("Error: Failed to run the assembler, {0}", assembler.LastMessage);
 					IsInError=true;
-          MDTrace.WriteLine(LogLevel.DEBUG, LastMessage);
+          MDTrace.WriteLine(LogLevel.DEBUG,LastMessage);
           return false;
         }
         if (Trace) DumpSymbolTable();
@@ -180,7 +202,7 @@ namespace Axiom.Interpreter
       {
         LastMessage=String.Format("Exception:{0}",exception.ToString());
 				IsInError=true;
-        MDTrace.WriteLine(LogLevel.DEBUG, LastMessage);
+        MDTrace.WriteLine(LogLevel.DEBUG,LastMessage);
         return false;
       }
       finally
@@ -194,6 +216,11 @@ namespace Axiom.Interpreter
       }
     }
 
+    /// <summary>
+    /// Disassemble - This method does not execute code.  It scans, parses, and disassembles the geenrated bytecode
+    /// </summary>
+    /// <param name="expression"></param>
+    /// <returns></returns>
     public List<String> Disassemble(String expression)
     {
       BinaryReader binaryReader = null;
@@ -208,22 +235,22 @@ namespace Axiom.Interpreter
       {
 			  IsInError=false;
 				LastMessage="";
-        symbolTable = new SymbolTable();
+        SymbolTable localSymbolTable = new SymbolTable();
         binaryReader = new BinaryReader(Utility.StreamFromString(expression));
         binaryWriter = new BinaryWriter(new MemoryStream());
-        Scanner scanner = new Scanner(binaryReader, binaryWriter, symbolTable);
+        Scanner scanner = new Scanner(binaryReader, binaryWriter, localSymbolTable);
         scanner.Debug = Trace;
         if (!scanner.Analyze())
         {
           LastMessage="Failed to scan the input document, possible invalid character sequence.";
 					IsInError=true;
-          MDTrace.WriteLine(LogLevel.DEBUG, LastMessage);
+          MDTrace.WriteLine(LogLevel.DEBUG,LastMessage);
           return disassembly;
         }
         binaryWriter.BaseStream.Seek(0, SeekOrigin.Begin);
         parserReader = new BinaryReader(binaryWriter.BaseStream);
         parserWriter = new BinaryWriter(new MemoryStream());
-        Parser parser = new Parser(parserReader, parserWriter, symbolTable);
+        Parser parser = new Parser(parserReader, parserWriter, localSymbolTable);
         parser.Debug = Trace;
         parser.Parse();
         parseSymbolCount=parser.ParseSymbolsCount;
@@ -231,12 +258,12 @@ namespace Axiom.Interpreter
         {
           LastMessage=String.Format("Failed to parse the input, {0} at {1}", parser.LastMessage, parser.LastLineNumber);
 					IsInError=true;
-          MDTrace.WriteLine(LogLevel.DEBUG, LastMessage);
+          MDTrace.WriteLine(LogLevel.DEBUG,LastMessage);
           return disassembly;
         }
         parserWriter.BaseStream.Seek(0, SeekOrigin.Begin);
         assemblerReader = new BinaryReader(parserWriter.BaseStream);
-        assembler = new Assembler(assemblerReader, symbolTable);
+        assembler = new Assembler(assemblerReader, localSymbolTable);
         assembler.Debug = Trace;
         return assembler.Disassemble();
       }
@@ -244,7 +271,7 @@ namespace Axiom.Interpreter
       {
         LastMessage=String.Format("Exception:{0}",exception.ToString());
 				IsInError=true;
-        MDTrace.WriteLine(LogLevel.DEBUG, LastMessage);
+        MDTrace.WriteLine(LogLevel.DEBUG,LastMessage);
         return disassembly;
       }
       finally
@@ -258,7 +285,6 @@ namespace Axiom.Interpreter
       }
     }
 
-
 //  The cache will not work as effectively if the expression variables are not loaded directly into the SymbolTable
     public bool ApplyRuleWithCache(String expression)
     {
@@ -304,6 +330,7 @@ namespace Axiom.Interpreter
         if (null != assembler) { assembler.Dispose(); }
       }
     }
+
     public AxiomResult SyntaxCheck(String expression)
     {
       BinaryReader binaryReader = null;
@@ -353,6 +380,7 @@ namespace Axiom.Interpreter
         if (null != parserWriter) { parserWriter.Close(); parserWriter.Dispose(); }
       }
     }
+
     private Stream Compile(String expression, bool includeCodeEnd = true)
     {
       BinaryReader binaryReader = null;
@@ -407,6 +435,7 @@ namespace Axiom.Interpreter
         if (null != parserReader) { parserReader.Close();parserReader.Dispose(); }
       }
     }
+
     private void DumpSymbolTable()
     {
       MDTrace.WriteLine(LogLevel.DEBUG,"********************************************************* O U T P U T ************************************************");

AxiomUnitTests/AssemblerTests.cs

@@ -0,0 +1,815 @@
+using System;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using Axiom.Utils;
+using Axiom.Interpreter;
+using System.IO;
+
+namespace AxiomUnitTestProject
+{
+
+  [TestClass]
+  public class AssemblerTests
+  {
+
+    [TestMethod]																																																				  
+    public void BreakStatementVariant6()
+    {
+        String expression=@"
+        A=1;
+        WHILE(A<10)
+        {
+          BREAK;
+          BREAK;
+        }";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsFalse(codeRunner.Execute(expression),codeRunner.LastMessage);
+    }
+
+    [TestMethod]																																																				  
+    public void BreakStatementVariant5()
+    {
+        String expression=@"
+        A=1;
+        B=1;
+        C=1;
+        D=1;
+        WHILE(A<10)
+        {
+          WHILE(B<10)
+          {
+            WHILE(C<10)
+            {
+              WHILE(D<10)
+              {
+                A=A+1;
+                B=B+1;
+                C=C+1;
+                D=D+1;
+                IF(D==10)THEN BREAK;
+                BREAK;
+              }
+              BREAK;
+            }
+            BREAK;
+          }
+          BREAK;
+        }";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(2));
+      Assert.IsTrue(codeRunner.GetValue<double>("B").Equals(2));
+      Assert.IsTrue(codeRunner.GetValue<double>("C").Equals(2));
+      Assert.IsTrue(codeRunner.GetValue<double>("D").Equals(2));
+    }
+
+    [TestMethod]																																																				  
+    public void BreakStatementVariant4()
+    {
+       String expression=@"
+        A=1;
+        B=1;
+        WHILE(A<10)
+        {
+          WHILE(B<10)
+          {
+            IF(B==100)THEN BREAK;
+            B=B+1;
+          }
+          IF(A==100)THEN BREAK;
+          A=A+1;
+        }"; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(10));
+      Assert.IsTrue(codeRunner.GetValue<double>("B").Equals(10));
+    }
+
+    [TestMethod]																																																				  
+    public void BreakStatementVariant3()
+    {
+       String expression=@"
+        A=1;
+        B=1;
+        WHILE(A<10)
+        {
+          WHILE(B<10)
+          {
+            IF(B==1)THEN BREAK;
+            B=B+1;
+          }
+          IF(A==1)THEN BREAK;
+          A=A+1;
+        }"; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(1));
+      Assert.IsTrue(codeRunner.GetValue<double>("B").Equals(1));
+    }
+
+    [TestMethod]																																																				  
+    public void BreakStatementVariant2()
+    {
+      String expression=@"
+        A=1;
+        WHILE(A<10)
+        {
+          IF(A==1)THEN BREAK;
+          A=A+1;
+        }
+        "; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(1));
+    }
+
+    [TestMethod]																																																				  
+    public void BreakStatementVariant1()
+    {
+      String expression=@"
+        break;
+        "; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsFalse(codeRunner.Execute(expression),codeRunner.LastMessage);
+    }
+
+    [TestMethod]																																																				  
+    public void DeclarationStatementVariant3()
+    {
+      String expression=@"
+        DECLARE A;
+				DECLARE B;
+				B=5;
+        DECLARE C;
+        D=6;
+        "; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("D").Equals(6));
+    }
+
+    [TestMethod]																																																				  
+    public void DeclarationStatementVariant2()
+    {
+      String expression=@"
+        DECLARE A;
+				DECLARE B;
+				B=5;
+        DECLARE C;
+        "; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("B").Equals(5));
+    }
+
+    [TestMethod]																																																				  
+    public void DeclarationStatementVariant1()
+    {
+      String expression=@"
+        DECLARE A;
+				DECLARE B;
+				B=5;
+        "; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("B").Equals(5));
+    }
+
+		[TestMethod]																																																				  
+    public void ForStatementVariant3()
+    {
+      String expression=@"
+        DECLARE A,J,TOTAL;
+				A=1;
+        J=1;
+        TOTAL=0;
+        FOR(A=1;A<=10;A=A+1)
+        {
+          FOR(J=1;J<=10;J=J+1)
+          {
+            BREAK;
+            TOTAL=TOTAL+1
+          }
+        }
+        "; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("J").Equals(1));
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(11));
+      Assert.IsTrue(codeRunner.GetValue<double>("TOTAL").Equals(0));
+    }
+
+		[TestMethod]																																																				  
+    public void ForStatementVariant2()
+    {
+      String expression=@"
+        DECLARE A,J,TOTAL;
+				A=1;
+        J=1;
+        TOTAL=0;
+        FOR(A=1;A<=10;A=A+1)
+        {
+          FOR(J=1;J<=10;J=J+1)
+          {
+            TOTAL=TOTAL+1;
+          }
+        }
+        "; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("J").Equals(11));
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(11));
+      Assert.IsTrue(codeRunner.GetValue<double>("TOTAL").Equals(100));
+    }
+
+		[TestMethod]																																																				  
+    public void ForStatementVariant1()
+    {
+      String expression=@"
+        DECLARE A,J;
+				A=1;
+        J=1;
+        FOR(A=1;A<10;A=A+1)
+        {
+          J=J+1;
+        }
+        "; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("J").Equals(10));
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(10));
+    }
+
+		[TestMethod]																																																				  
+    public void WhileStatementVariant4()
+    {
+      String expression=@"
+        DECLARE A,B;
+				A=1;
+				B=5;
+        ITERATIONS=0;
+        WHILE(A<=10)
+        {
+          B=1;
+          WHILE(B<=5)
+          {
+            B=B+1;
+            ITERATIONS=ITERATIONS+1;
+          }
+          A=A+1;
+        }"; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(11));
+      Assert.IsTrue(codeRunner.GetValue<double>("ITERATIONS").Equals(50));
+    }
+
+		[TestMethod]																																																				  
+    public void WhileStatementVariant3()
+    {
+      String expression=@"
+        DECLARE A,B;
+				A=1;
+				B=5;
+        WHILE(A<B)
+        {
+          A=A+1;
+        }"; 
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(5));
+    }
+
+    [TestMethod]
+    public void WhileStatementVariant2()
+    {
+      String expression="DECLARE A,B;A=1;B=5;WHILE(A<B)A=A+1;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+			Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(5));
+    }
+
+    [TestMethod]
+    public void WhileStatementVariant1()
+    {
+      String expression="DECLARE A,B;A=1;B=5;WHILE(A<B){A=A+1;}";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+			Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(5));
+    }
+
+    [TestMethod]
+    public void DeclarationsVariant4()
+    {
+      String expression="DECLARE R,user_a,user_b,user_c;R=7;user_a=66;user_b=66;user_c=66;IF(R>=5){user_a=1;user_b=1;user_c=1;}";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+    }
+
+    [TestMethod]
+    public void DeclarationsVariant3()
+    {
+      String expression="DECLARE VAR1,VAR1;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsFalse(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.LastMessage.Contains("The variable 'VAR1' has already been declared."));
+    }
+
+    [TestMethod]
+    public void DeclarationsVariant2()
+    {
+      String expression="DECLARE VAR1,VAR2;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+    }
+
+    [TestMethod]
+    public void DeclarationsVariant1()
+    {
+      String expression="DECLARE VAR1;DECLARE VAR2;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+    }
+
+    [TestMethod]
+    public void LowerCall()
+    {
+      String expression="DECLARE VAR1;VAR1='Hello ';VAR1=TRIM(VAR1);VAR1=LOWER(VAR1);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("VAR1").Equals("hello"));
+    }
+
+    [TestMethod]
+    public void UpperCall()
+    {
+      String expression="DECLARE VAR1;VAR1='Hello ';VAR1=TRIM(VAR1);VAR1=UPPER(VAR1);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("VAR1").Equals("HELLO"));
+    }
+
+    [TestMethod]
+    public void TrimCall()
+    {
+      String expression="DECLARE VAR1;VAR1='Hello ';VAR1=TRIM(VAR1);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("VAR1").Equals("Hello"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant20()
+    {
+      // There is a missing right paren in the if statement nesting so we expect a syntax error
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=1;IF((((((VAR1=='YES'))))) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsFalse(codeRunner.Execute(expression));
+      Assert.IsTrue(codeRunner.LastMessage.Contains("<Syntax Error>"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant19()
+    {
+      String expression = "DECLARE a,b;a=1;b=1;IF(1+1)upper('Foo');";
+      CodeRunner codeRunner=new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.ParseSymbolsCount.Equals(0),"Expected parse symbols count to be zero.");
+    }
+
+    [TestMethod]
+    public void IfStatementVariant18()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1=2;IF(VAR1==2) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("TRUE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant17()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=1;IF(VAR1=='YES') THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("TRUE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant16()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=1;IF((((((VAR1=='YES')))))) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("TRUE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant15()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF((VAR1=='YES') AND VAR2=='NO') THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("FALSE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant14()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=2;IF(VAR1=='YES' AND (VAR2=='YES') AND VAR4==1) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("FALSE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant13()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF(VAR1=='YES' AND (VAR2=='YES') AND VAR4==1) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("TRUE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant12()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF((VAR1=='YES') OR (VAR2=='YES') AND (VAR4==1)) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("TRUE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant11()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='NO';VAR2='YES';VAR4=1;IF(VAR1=='YES' OR VAR2=='YES' AND VAR4==2) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("FALSE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant10()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF(VAR1=='YES' OR VAR2=='YES' AND VAR4==2) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("TRUE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant9()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=2;IF(VAR1=='NO' OR (VAR2=='YES' AND VAR4==1)) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("FALSE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant8()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF(VAR1=='NO' OR (VAR2=='YES' AND VAR4==1)) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("TRUE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant7()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=2;IF((VAR1=='YES') AND VAR2=='NO' AND VAR4==1) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("FALSE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant6()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=1;IF((VAR1=='YES') AND VAR2=='NO' AND VAR4==1) THEN RESULT='TRUE' ELSE RESULT='FALSE';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("TRUE"));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant5()
+    {
+      String expression="DECLARE A,B,RESULT;A=1;B=2;IF(A==1 AND B==2)THEN RESULT=1 ELSE RESULT=0;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("RESULT").Equals(1.00));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant4()
+    {
+      String expression="DECLARE A,B;A=99;if(A<>99)then B=1 else B=2;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("B").Equals(2.00));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant3()
+    {
+      String expression="DECLARE R,user_a,user_b,user_c;R=7;user_a=66;user_b=66;user_c=66;IF(R>=5){user_a=1;user_b=1;user_c=1;}";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("user_a").Equals(1.00));
+      Assert.IsTrue(codeRunner.GetValue<double>("user_b").Equals(1.00));
+      Assert.IsTrue(codeRunner.GetValue<double>("user_c").Equals(1.00));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant2()
+    {
+      String expression="DECLARE A,B,C;A=1;B=2;C=3;IF(B<A){A=0;B=0;C=0;}ELSE{A=1;B=1;C=1;}";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("A").Equals(1.00));
+      Assert.IsTrue(codeRunner.GetValue<double>("B").Equals(1.00));
+      Assert.IsTrue(codeRunner.GetValue<double>("C").Equals(1.00));
+    }
+
+    [TestMethod]
+    public void IfStatementVariant1()
+    {
+      String expression="R_THRESHHOLD=4;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      double b = codeRunner.GetValue<double>("R_THRESHHOLD");
+      Assert.IsTrue(b.Equals(4.00));
+    }
+
+    private class InjectionClass
+    {
+      public double RMultiple { get { return (CurrentPrice-PurchasePrice)/R; } }  
+      public double CurrentPrice{ get; set; }
+      public double PurchasePrice{ get; set; }
+      public double R { get; set; } 
+    }
+
+    [TestMethod]
+    public void Injection()
+    {
+      double tolerance=.01;
+      String expression=@"
+        R_THRESHHOLD=4;
+        MAX_ATR=3;
+        MAX_R=10;
+        FACTOR=MAX_ATR/MAX_R;
+        MULTIPLIER=MAX_ATR;
+        IF(RMultiple>R_THRESHHOLD)
+        {
+          MULTIPLIER=FACTOR*RMultiple;
+        }"; 
+        
+      InjectionClass injectionClass = new InjectionClass();  
+      injectionClass.CurrentPrice=220;
+      injectionClass.PurchasePrice=195.90;
+      injectionClass.R=5.00;        
+         
+      CodeRunner codeRunner = new CodeRunner();
+      SymbolTable symbolTable=codeRunner.SymbolTable;
+      symbolTable.AddObjects(new Object[]{injectionClass}.ToList());
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      double multiplier = codeRunner.GetValue<double>("MULTIPLIER");
+      Assert.IsTrue((1.446+tolerance>=multiplier) && (1.446-tolerance<=multiplier));
+    }
+
+    [TestMethod]
+    public void Substring()
+    {
+      String expression="DECLARE CURRENCY,START_INDEX,LENGTH,CURRENCY_CODE;CURRENCY='MXN12345';START_INDEX=1;LENGTH=3;CURRENCY_CODE=SUBSTRING(CURRENCY,START_INDEX,LENGTH);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("CURRENCY_CODE").Equals("MXN"));
+    }
+
+    [TestMethod]
+    public void InStatement()
+    {
+      String expression="DECLARE CURRENCY,A;CURRENCY='MXN';A=CURRENCY in('USD','JPY');";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<bool>("A").Equals(false));
+    }
+
+    [TestMethod]
+    public void InStatement2()
+    {
+      String expression="DECLARE CURRENCY,A;CURRENCY='MXN';A=CURRENCY in('USD','JPY','MXN');";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<bool>("A").Equals(true));
+    }
+
+    [TestMethod]
+    public void NestedParens()
+    {
+      String expression="DECLARE A,B,C;A=100/50;B=100-(((2*2)*8)*9);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("B").Equals(-188));
+    }
+
+    [TestMethod]
+    public void Power()
+    {
+      String expression="DECLARE A,B,C;A=100;B=.5;C=pow(A,B);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("C").Equals(10));
+    }
+
+    [TestMethod]
+    public void OrderOfOperations()
+    {
+      String expression="DECLARE NUM1;NUM1=3*4*(2+1)";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("NUM1").Equals(36));
+    }
+
+    [TestMethod]
+    public void NumericalEquality()
+    {
+      String expression="DECLARE NOTIONAL,DELTA,DELTA_ADJUSTED_NOTIONAL;NOTIONAL=20.00;if(2==2)then DELTA=.01 else DELTA=1.00;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("DELTA").Equals(.01));
+    }
+
+    [TestMethod]
+    public void Division()
+    {
+      String expression="DECLARE NOTIONAL,DELTA,DELTA_ADJUSTED_NOTIONAL;NOTIONAL=1000.00;DELTA=.25;DELTA_ADJUSTED_NOTIONAL=NOTIONAL/DELTA;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("DELTA_ADJUSTED_NOTIONAL").Equals(4000));
+    }
+
+    [TestMethod]
+    public void Addition()
+    {
+      String expression="DECLARE a,b,c;a=100;b=100+a;c=-100;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("b").Equals(200));
+    }
+
+    [TestMethod]
+    public void NullCoalescing()
+    {
+      String expression="DECLARE RESULT,A,B,C,D;A=null;B=null;C='NotNull';RESULT=ISNULL(A,B,C);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("NotNull"));
+    }
+
+    [TestMethod]
+    public void DateComparisons()
+    {
+      String expression="DECLARE RESULT,A,B,C,D;A=CONVERT('01-01-2018','System.DateTime');B=CONVERT('01-02-2018','System.DateTime');IF(A>B) THEN RESULT='01-01-2018 IS GREATER THAN 01-02-2018' ELSE RESULT='01-02-2018 IS GREATER THAN 01-01-2018';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("RESULT").Equals("01-02-2018 IS GREATER THAN 01-01-2018"));
+    }
+
+    [TestMethod]
+    public void StringMultiplication()
+    {
+      String expression="DECLARE A,B,C;A='45';B='2';C=A*B;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("C").Equals(90.00));
+    }
+
+    [TestMethod]
+    public void ExponentialNotation()
+    {
+      String expression="DECLARE OAC;OAC=-3.52E-05;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("OAC").Equals(-3.52E-05));
+    }
+
+
+    [TestMethod]
+    public void StringConcatenation()
+    {
+      String expression="DECLARE ENTITY_ID,AXIOM_META_TAG;ENTITY_ID=148;IF(ENTITY_ID==148)THEN AXIOM_META_TAG=ENTITY_ID+'_BG' ELSE AXIOM_META_TAG=null;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("AXIOM_META_TAG").Equals("148_BG"));
+    }
+
+    [TestMethod]
+    public void StringConcatenation2()
+    {
+      String expression="DECLARE A,B,C;A='45';B='2';C=A+B;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("C").Equals("452"));
+    }
+
+    [TestMethod]
+    public void StringComparison()
+    {
+      String expression="DECLARE ENTITY_ID;ENTITY_ID='';IF(ENTITY_ID=='')THEN ENTITY_ID='ENTITY_ID IS BLANK'ELSE ENTITY_ID='ENTITY_ID IS NOT BLANK';";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("ENTITY_ID").Equals("ENTITY_ID IS BLANK"));
+    }
+
+    [TestMethod]
+    public void DateConversion()
+    {
+      String expression="DECLARE ENTITY_ID,EFFECTIVE_DATE;ENTITY_ID=null;IF(ENTITY_ID==null)THEN EFFECTIVE_DATE=CONVERT('2/1/2024','System.DateTime');";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<DateTime>("EFFECTIVE_DATE").Equals(new DateTime(2024,2,1)));
+    }
+  
+    [TestMethod]
+    public void LikeClause()
+    {
+      String expression="DECLARE FIN.Securities.IndustryClass4,FIN.Securities.Country,FIN.Securities.ISIN;FIN.Securities.ISIN='ARARGE';IF(FIN.Securities.ISIN LIKE 'ARARGE'){FIN.Securities.IndustryClass4 = 'Treasury Bond';FIN.Securities.Country='USD'};";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<string>("FIN.Securities.IndustryClass4").Equals("Treasury Bond"));
+      Assert.IsTrue(codeRunner.GetValue<string>("FIN.Securities.Country").Equals("USD"));
+    }
+
+     [TestMethod]
+    public void AbsoluteValueVariant2()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1=-1;VAR2=-3;VAR2=ABS(VAR2)+1;";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("VAR2").Equals(4));
+    }
+
+    [TestMethod]
+    public void AbsoluteValueVariant1()
+    {
+      String expression="DECLARE VAR1,VAR2,VAR4,RESULT;VAR1=((ABS(-1)+2)+3);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("VAR1").Equals(6));
+    }
+
+    [TestMethod]
+    public void Multiplication()
+    {
+      String expression="DECLARE var1,var2,var3,var4;var1=1;var2=2;var3=3;var4=var1*var2*var3*var1*var2*var3*abs(var1);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("var4").Equals(36.00));
+    }
+
+    [TestMethod]
+    public void AbsoluteValueConvesion()
+    {
+      String expression="DECLARE var1,var2,var3,var4;var1=-1;var2=-2;var3=-3;var4=abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2);";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("var4").Equals(4096.00));
+    }
+
+
+    [TestMethod]
+    public void StringToDoubleConvesion()
+    {
+      String expression="DECLARE var1,var2,var3,var4;var1='2';var2='4';var3='6';var4=CONVERT(var1,'System.Double')*CONVERT(var2,'System.Double')*CONVERT(var3,'System.Double');";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<double>("var1").Equals(2.00));
+    }
+
+    [TestMethod]
+    public void UpperCaseShouldConvert()
+    {
+      String expression="DECLARE var1,var2,var3,var4;var1='Hello';var2=' ';var3='World';var4=UPPER(var1)+UPPER(var2)+UPPER(var3)";
+      CodeRunner codeRunner = new CodeRunner();
+      Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+      Assert.IsTrue(codeRunner.GetValue<String>("var4").Equals("HELLO WORLD"));
+    }
+
+    [TestMethod]
+    public void AssembleAllUseCases()
+    {
+      foreach(String expression in TestData.CodeLines())
+      {
+        CodeRunner codeRunner= new CodeRunner();
+        Assert.IsTrue(codeRunner.Execute(expression),codeRunner.LastMessage);
+        Assert.IsTrue(codeRunner.ParseSymbolsCount.Equals(0),"Expected parse symbols to be zero.");
+      }
+    }
+  }
+}
+

AxiomUnitTests/AxiomUnitTests.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>disable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Moq" Version="4.20.2" />
+    <PackageReference Include="MSTest.TestAdapter" Version="3.1.1" />
+    <PackageReference Include="MSTest.TestFramework" Version="3.1.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../Axiom/Axiom.Core/Axiom.Core.csproj" />
+  </ItemGroup>
+
+
+</Project>

AxiomUnitTests/AxiomUnitTests.sln

@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2013
+VisualStudioVersion = 12.0.21005.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AxiomUnitTests", "AxiomUnitTests.csproj", "{E2FC10FA-2B8A-4CEB-B7C6-960FA6A3AC6F}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Axiom.Core", "..\Axiom\Axiom.Core\Axiom.Core.csproj", "{F0F0F2B4-BB86-49B5-BA93-2642637033D6}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E2FC10FA-2B8A-4CEB-B7C6-960FA6A3AC6F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E2FC10FA-2B8A-4CEB-B7C6-960FA6A3AC6F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E2FC10FA-2B8A-4CEB-B7C6-960FA6A3AC6F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E2FC10FA-2B8A-4CEB-B7C6-960FA6A3AC6F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F0F0F2B4-BB86-49B5-BA93-2642637033D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F0F0F2B4-BB86-49B5-BA93-2642637033D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F0F0F2B4-BB86-49B5-BA93-2642637033D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F0F0F2B4-BB86-49B5-BA93-2642637033D6}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

AxiomUnitTests/ParserTests.cs

@@ -0,0 +1,37 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using Axiom.Utils;
+using Axiom.Interpreter;
+using System.IO;
+
+namespace AxiomUnitTestProject
+{
+  [TestClass]
+  public class ParserTests
+  {
+    [TestMethod]
+    public void ParserShouldParseAll()
+    {
+      List<String> codeLines = TestData.CodeLines();
+      foreach(String expression in codeLines)
+      {
+        BinaryWriter binaryWriter=new BinaryWriter(new MemoryStream());
+        SymbolTable symbolTable = new SymbolTable();
+        BinaryReader binaryReader = null;
+        binaryReader = new BinaryReader(Utility.StreamFromString(expression));
+        Scanner scanner = new Scanner(binaryReader, binaryWriter, symbolTable);
+        scanner.Debug=false;
+        Console.WriteLine("Expression:\""+expression+"\"");
+        Assert.IsTrue(scanner.Analyze());
+        binaryWriter.BaseStream.Seek(0, SeekOrigin.Begin);
+        BinaryReader parserReader = new BinaryReader(binaryWriter.BaseStream);
+        BinaryWriter parserWriter = new BinaryWriter(new MemoryStream());
+        Parser parser = new Parser(parserReader,parserWriter,symbolTable);
+        parser.Debug=true;
+        parser.Parse();
+        Assert.IsFalse(parser.IsInError,parser.LastMessage);
+      }
+    }
+  }
+}

AxiomUnitTests/ScannerTests.cs

@@ -0,0 +1,30 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using Axiom.Utils;
+using Axiom.Interpreter;
+using System.IO;
+
+namespace AxiomUnitTestProject
+{
+  [TestClass]
+  public class ScannerTests
+  {
+    [TestMethod]
+    public void ScannerShouldScan()
+    {
+      List<String> codeLines = TestData.CodeLines();
+      foreach(String expression in codeLines)
+      {
+        BinaryWriter binaryWriter=new BinaryWriter(new MemoryStream());
+        SymbolTable symbolTable = new SymbolTable();
+        BinaryReader binaryReader = null;
+        binaryReader = new BinaryReader(Utility.StreamFromString(expression));
+        Scanner scanner = new Scanner(binaryReader, binaryWriter, symbolTable);
+        Console.WriteLine("Expression:\""+expression+"\"");
+        Assert.IsTrue(scanner.Analyze());
+        Console.WriteLine("**************************");
+      }
+    }
+  }
+}

AxiomUnitTests/TestData.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AxiomUnitTestProject
+{
+  public class TestData
+  {
+    public static List<String> CodeLines()
+    {
+      List<String> codeLines = new List<String>();
+			codeLines.Add("DECLARE A,B;A=1;B=5;WHILE(A<B)A=A+1;");
+			codeLines.Add("DECLARE A,B;A=1;B=5;WHILE(A<B){A=A+1;}");
+      codeLines.Add("DECLARE R,user_a,user_b,user_c;R=7;user_a=66;user_b=66;user_c=66;IF(R>=5){user_a=1;user_b=1;user_c=1;}");
+      codeLines.Add("DECLARE price,operation;operation='OPEN';price=GETPRICE('MIDD','07-12-2021',operation);");
+      codeLines.Add("DECLARE var1,var2,var3,var4;var1='Hello';var2=' ';var3='World';var4=UPPER(var1)+UPPER(var2)+UPPER(var3)");
+      codeLines.Add("DECLARE var1,var2,var3,var4;var1='2';var2='4';var3='6';var4=CONVERT(var1,'System.Double')+CONVERT(var2,'System.Double')+CONVERT(var3,'System.Double');");
+      codeLines.Add("DECLARE var1,var2,var3,var4;var1='2';var2='4';var3='6';var4=CONVERT(var1,'System.Double')*CONVERT(var2,'System.Double')*CONVERT(var3,'System.Double');");
+      codeLines.Add("DECLARE var1,var2,var3,var4;var1=-1;var2=-2;var3=-3;var4=abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2)*abs(var2);");
+      codeLines.Add("DECLARE var1,var2,var3,var4;var1=1;var2=2;var3=3;var4=var1*var2*var3*var1*var2*var3*abs(var1);");
+      codeLines.Add("DECLARE var1,var2,var3,var4;var1=1;var2=2;var3=3;var4=var1*var2*var3*var1*var2*var3;");
+      codeLines.Add("DECLARE FIN.Securities.IndustryClass4,FIN.Securities.Country,FIN.Securities.ISIN;FIN.Securities.ISIN='ARARGE';IF(FIN.Securities.ISIN LIKE 'ARARGE'){FIN.Securities.IndustryClass4 = 'Treasury Bond';FIN.Securities.Country='USD'};");
+      codeLines.Add("#directive_clear_modified;");
+      codeLines.Add("DECLARE ENTITY_ID,EFFECTIVE_DATE;ENTITY_ID=null;IF(ENTITY_ID==null)THEN EFFECTIVE_DATE=CONVERT('1/1/1','System.DateTime');");
+      codeLines.Add("DECLARE ENTITY_ID;ENTITY_ID='';IF(ENTITY_ID=='')THEN ENTITY_ID='ENTITY_ID IS BLANK'ELSE ENTITY_ID='ENTITY_ID IS NOT BLANK';");
+      codeLines.Add("DECLARE ENTITY_ID,AXIOM_META_TAG;ENTITY_ID=148;IF(ENTITY_ID==148)THEN AXIOM_META_TAG=ENTITY_ID+'_BG' ELSE AXIOM_META_TAG=null;");
+      codeLines.Add("DECLARE OAC;OAC=-3.52E-05;");
+      codeLines.Add("DECLARE FIN.Analytics.OAD,LAND.STG_EC.SecurityIdentifier;FIN.Analytics.OAD=0.50;LAND.STG_EC.SecurityIdentifier = '397863';IF(LAND.STG_EC.SecurityIdentifier == '397863') THEN FIN.Analytics.OAD = FIN.Analytics.OAD*2.00;");
+      codeLines.Add("DECLARE A,B;A=99;if(A<>99)then B=1 else B=2;");
+      codeLines.Add("DECLARE A,B,C;A='45';B='2';C=A+B;");    // Ok, concatenation of two strings
+      codeLines.Add("DECLARE A,B,C;A='45';B='2';C=A*B;");    // Converts the strings to double and then performs the multiplication
+      codeLines.Add("DECLARE A,B,C,D;A='45';B='2';D='2';C=CONVERT(A,'System.Double')*CONVERT(B,'System.Double')*CONVERT(D,'System.Double');");    // Ok, multiplying numerical values
+      codeLines.Add("DECLARE A,B,C,D;A='45';B='2';D='2';C=CONVERT(A,'System.Double')*CONVERT(B,'System.Double')*2;");    // Ok, multiplying numerical values
+      codeLines.Add("DECLARE A,B,C,D;A='45';B='2';D='2';C=CONVERT(A,'System.Double')+CONVERT(B,'System.Double');");    // Ok, multiplying numerical values
+      codeLines.Add("DECLARE A,B,C,D;A='45';B='2';D='2';C=CONVERT(A,'System.Double')+CONVERT(B,'System.Double')+CONVERT(D,'System.Double');");    // Ok, multiplying numerical values
+      codeLines.Add("DECLARE RESULT,A,B,C,D;A=CONVERT('01-01-2018','System.DateTime');B=CONVERT('01-02-2018','System.DateTime');IF(A>B) THEN RESULT='01-01-2018 IS GREATER THAN 01-02-2018' ELSE RESULT='01-02-2018 IS GREATER THAN 01-01-2018';");   
+      codeLines.Add("DECLARE RESULT,A,B,C,D;A=null;B=null;C='NotNull';RESULT=ISNULL(A,B,C);");   
+      codeLines.Add("DECLARE a,b,c;a=100;b=100+a;c=-100;");
+      codeLines.Add("DECLARE NOTIONAL,DELTA,DELTA_ADJUSTED_NOTIONAL;NOTIONAL=1000.00;DELTA=.2017;DELTA_ADJUSTED_NOTIONAL=NOTIONAL/DELTA;");
+      codeLines.Add("DECLARE NOTIONAL,DELTA,DELTA_ADJUSTED_NOTIONAL;NOTIONAL=20;DELTA=100;DELTA_ADJUSTED_NOTIONAL=NOTIONAL/DELTA;");
+      codeLines.Add("DECLARE NOTIONAL,DELTA,DELTA_ADJUSTED_NOTIONAL;NOTIONAL=20.00;if(NOTIONAL==20)then DELTA=.01 else DELTA=1.00;");
+      codeLines.Add("DECLARE NOTIONAL,DELTA,DELTA_ADJUSTED_NOTIONAL;NOTIONAL=10.00;if(NOTIONAL<>20) then DELTA=.01 else DELTA=1.00;");
+      codeLines.Add("DECLARE NOTIONAL,DELTA,DELTA_ADJUSTED_NOTIONAL;NOTIONAL=20.00;if(2==2)then DELTA=.01 else DELTA=1.00;");
+      codeLines.Add("DECLARE NOTIONAL,DELTA,DELTA_ADJUSTED_NOTIONAL;NOTIONAL=20.00;if(3==2)then DELTA=.01 else DELTA=1.00;");
+      codeLines.Add("DECLARE NUM1;NUM1=3*4*(2+1)");
+      codeLines.Add("DECLARE A,B,C;A=2;B=.5;C=pow(A,B);");
+      codeLines.Add("DECLARE A,B,C;A=100;IF(A<200) THEN B=1 ELSE B=0;");
+      codeLines.Add("DECLARE A,B,C;A=CONVERT('03-10-2018','System.DateTime');");
+      codeLines.Add("DECLARE A,B,C;A=CONVERT('2','System.Int32');B=CONVERT('3','System.Int32');");
+      codeLines.Add("DECLARE A,B,C;A=100/50;B=100-(((2*2)*8)*9);");
+      codeLines.Add("DECLARE A,B,C;A=abs(-50);");
+      codeLines.Add("DECLARE A,B,C;A=abs(-50);");
+      codeLines.Add("DECLARE A,B,C;A=99;");
+      codeLines.Add("DECLARE A,B,C;A=CONVERT('2','System.Int32');B=CONVERT('2','System.Int32');IF(A==B)THEN C=1 ELSE C=2;");
+      codeLines.Add("DECLARE CURRENCY,A;CURRENCY='MXN';A=CURRENCY in('USD','JPY');");
+      codeLines.Add("DECLARE CURRENCY,RESULT;CURRENCY='MXN';if(CURRENCY in('USD','JPY','MXN'))THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE CURRENCY,RESULT;CURRENCY='MXN';if(CURRENCY LIKE '%MXN%') THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE CURRENCY,START_INDEX,LENGTH,CURRENCY_CODE;CURRENCY='MXN12345';START_INDEX=1;LENGTH=3;CURRENCY_CODE=SUBSTRING(CURRENCY,START_INDEX,LENGTH);");
+      codeLines.Add("DECLARE IS_PRIMARY_LEG,SEC_ID,LEG;IS_PRIMARY_LEG='FALSE';SEC_ID='FXF12345678_1';LEG=SUBSTRING(SEC_ID,13,1);IF(LEG==1) THEN IS_PRIMARY_LEG='TRUE' ELSE IS_PRIMARY_LEG='FALSE';");
+      codeLines.Add("DECLARE A,B;A=100/50;B=100-(((2*2)*8)*9);");
+      codeLines.Add("DECLARE IS_PRIMARY_LEG,SEC_ID;IS_PRIMARY_LEG='FALSE';SEC_ID='FXF12345678_1';IF(SUBSTRING(SEC_ID,13,1)==1)THEN IS_PRIMARY_LEG='TRUE' ELSE IS_PRIMARY_LEG='FALSE';");
+      codeLines.Add("DECLARE SEC_ID,B;SEC_ID='FXF12345678_1';B=SUBSTRING(SEC_ID,13,1);");
+      codeLines.Add("DECLARE IS_PRIMARY_LEG,SEC_ID;IS_PRIMARY_LEG='FALSE';SEC_ID='FXF12345678_1';IF(SEC_ID LIKE '%_1')THEN IS_PRIMARY_LEG='TRUE' ELSE IS_PRIMARY_LEG='FALSE';");
+      codeLines.Add("DECLARE IS_FX,SEC_ID;IS_FX='FALSE';SEC_ID='FXF12345678_1';IF(SEC_ID LIKE 'FXF2%' OR SEC_ID LIKE 'FXF1%')THEN IS_FX='TRUE' ELSE IS_FX='FALSE';");
+      codeLines.Add("DECLARE A;A=2;");
+      codeLines.Add("DECLARE A,B,C,D;A=2;B=0;C=9;IF(A==2 AND B==0 AND C==10) THEN D=1 ELSE D=0;");
+      codeLines.Add("DECLARE LOCAL_AMT,SECURITY_ID,ENTRYCOST;LOCAL_AMT=50.00;SECURITY_ID='BP071917P1HY5';IF(SECURITY_ID in('BP071917P1HY5','BP071917P2HY5','BP071917P3HY5','BP071917P4HY5','BP071917P5HY5','BP071917P6HY5')) THEN ENTRYCOST=100.00 ELSE ENTRYCOST=LOCAL_AMT;");
+      codeLines.Add("DECLARE A;A=null;");
+      codeLines.Add("DECLARE A,B;A=1;B=2;IF(A==1){IF(B==2)THEN A=10 ELSE A=5;}else{A=3;B=4;}");
+      codeLines.Add("DECLARE A,B,C;A=null;B='TRUE';C=ISNULL(A,B);");
+      codeLines.Add("DECLARE A,B;A=1;B=2;IF(A==2)THEN B=100 ELSE B=200;");
+      codeLines.Add("DECLARE AssetLevel1,IndustryClass4,RESULT;AssetLevel1='FUTURE';IndustryClass4='BOND_FUTURES';IF(AssetLevel1 like 'FUTURE' AND IndustryClass4=='BOND_FUTURES')THEN RESULT=1 ELSE RESULT=0;");
+      codeLines.Add("DECLARE A,B,RESULT;A=1;B=2;IF(A==1 AND B==2)THEN RESULT=1 ELSE RESULT=0;");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=1;IF((VAR1=='YES') AND VAR2=='NO' AND VAR4==1) THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF(VAR1=='NO' OR (VAR2=='YES' AND VAR4==1)) THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF(VAR1=='YES' OR VAR2=='YES' AND VAR4==2) THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF((VAR1=='YES') OR (VAR2=='YES') AND (VAR4==1)) THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF(VAR1=='YES' AND (VAR2=='YES') AND VAR4==1) THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='YES';VAR4=1;IF((VAR1=='YES') AND VAR2=='NO') THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=1;IF((VAR1=='YES') AND VAR2=='NO') THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=1;IF((((((VAR1=='YES')))))) THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1='YES';VAR2='NO';VAR4=1;IF(VAR1=='YES') THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1=2;IF(VAR1==2) THEN RESULT='TRUE' ELSE RESULT='FALSE';");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1=((ABS(-1)+2)+3);");
+      codeLines.Add("DECLARE VAR1,VAR2,VAR4,RESULT;VAR1=-1;VAR2=-3;VAR2=ABS(VAR2)+1;");
+      codeLines.Add("DECLARE A,B,C;A=1;B=2;C=3;IF(B>A){A=0;B=0;C=0;}ELSE{A=1;B=1;C=1;}");
+      codeLines.Add("DECLARE A,B,C;A=1;B=2;C=3;IF(B<A){A=0;B=0;C=0;}ELSE{A=1;B=1;C=1;}");
+      codeLines.Add("DECLARE A,B,C;A=1;B=2;C=3;IF(B<A){A=0;B=0;C=0;}ELSE{A=1;B=1;C=1;}");
+      return codeLines;
+    }
+  }
+}