lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From synhers...@apache.org
Subject lucenenet git commit: Expressions test cases fixed
Date Fri, 06 Feb 2015 15:07:14 GMT
Repository: lucenenet
Updated Branches:
  refs/heads/master 48dfdc420 -> e2f872dc5


Expressions test cases fixed

Closes #78

Squashed and cleaned up, original PR was touching unnecessary files


Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/e2f872dc
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/e2f872dc
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/e2f872dc

Branch: refs/heads/master
Commit: e2f872dc533d1209f821fc3064e6ada4c4ef740e
Parents: 48dfdc4
Author: Itamar Syn-Hershko <itamar@code972.com>
Authored: Fri Feb 6 17:06:58 2015 +0200
Committer: Itamar Syn-Hershko <itamar@code972.com>
Committed: Fri Feb 6 17:06:58 2015 +0200

----------------------------------------------------------------------
 .../JS/JavascriptCompiler.cs                    | 317 +++++++---------
 .../JS/JavascriptLexer.cs                       | 361 ++++++++++---------
 src/Lucene.Net.Expressions/SimpleBindings.cs    | 224 ++++++------
 .../JS/TestJavascriptOperations.cs              |  26 +-
 .../TestExpressionValidation.cs                 |  10 +-
 5 files changed, 447 insertions(+), 491 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e2f872dc/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs b/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
index cda3042..041be58 100644
--- a/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
+++ b/src/Lucene.Net.Expressions/JS/JavascriptCompiler.cs
@@ -17,15 +17,10 @@
 
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Configuration;
-using System.Diagnostics;
-using System.Diagnostics.SymbolStore;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
-using System.Security.AccessControl;
 using Antlr.Runtime;
 using Antlr.Runtime.Tree;
 using Lucene.Net.Queries.Function;
@@ -36,20 +31,22 @@ namespace Lucene.Net.Expressions.JS
     /// <summary>An expression compiler for javascript expressions.</summary>
     /// <remarks>
     /// An expression compiler for javascript expressions.
-    /// <p>
+    /// <p/>
     /// Example:
     /// <pre class="prettyprint">
     /// Expression foo = JavascriptCompiler.compile("((0.3*popularity)/10.0)+(0.7*score)");
     /// </pre>
-    /// <p>
+    /// <p/>
     /// See the
     /// <see cref="Lucene.Net.Expressions.JS">package documentation</see>
     /// for
     /// the supported syntax and default functions.
     /// <p>
     /// You can compile with an alternate set of functions via
-    /// <see cref="Compile(string, System.Collections.Generic.IDictionary{K, V})
-    /// 	">Compile(string, System.Collections.Generic.IDictionary&lt;K, V&gt;)
+    /// <see Compile(string, System.Collections.Generic.IDictionary&lt;K, V&gt>
+    ///     <cref xml:space="preserve">Compile(string, System.Collections.Generic.IDictionary{K, V})
+    /// 	</cref>
+    ///    
     /// 	</see>
     /// .
     /// For example:
@@ -63,7 +60,7 @@ namespace Lucene.Net.Expressions.JS
     /// Expression foo = JavascriptCompiler.compile("cbrt(score)+ln(popularity)",
     /// functions,
     /// getClass().getClassLoader());
-    /// </pre>
+    /// </pre></p>
     /// </remarks>
     /// <lucene.experimental></lucene.experimental>
     public class JavascriptCompiler
@@ -95,14 +92,10 @@ namespace Lucene.Net.Expressions.JS
             return type.GetMethod(method, parms);
         }
 
-        private const int MAX_SOURCE_LENGTH = 16384;
-
         private readonly string sourceText;
 
         private readonly IDictionary<string, int> externalsMap = new HashMap<string, int>();
-
-
-
+        
         private TypeBuilder dynamicType;
 
         private readonly IDictionary<string, MethodInfo> functions;
@@ -119,12 +112,9 @@ namespace Lucene.Net.Expressions.JS
 
         private ILGenerator gen;
         private AssemblyBuilder asmBuilder;
-        private string fileName;
-        private ISymbolDocumentWriter debugDoc;
-        private int lineNum = 1;
-        private StreamWriter file;
         private MethodBuilder evalMethod;
-        private bool negate;
+        private ModuleBuilder modBuilder;
+
 
         // This maximum length is theoretically 65535 bytes, but as its CESU-8 encoded we dont know how large it is in bytes, so be safe
         // rcmuir: "If your ranking function is that large you need to check yourself into a mental institution!"
@@ -242,13 +232,13 @@ namespace Lucene.Net.Expressions.JS
         {
             var assemblyName = new AssemblyName("Lucene.Net.Expressions.Dynamic" + new Random().Next());
             asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndCollect);
-
-            ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule(assemblyName.Name + ".dll");
+            
+            modBuilder = asmBuilder.DefineDynamicModule(assemblyName.Name + ".dll", true);
+            
             dynamicType = modBuilder.DefineType(COMPILED_EXPRESSION_CLASS,
                 TypeAttributes.AnsiClass | TypeAttributes.AutoClass | TypeAttributes.Public | TypeAttributes.Class |
                 TypeAttributes.BeforeFieldInit | TypeAttributes.AutoLayout, EXPRESSION_TYPE);
-
-
+            
             ConstructorBuilder constructorBuilder = dynamicType.DefineConstructor(MethodAttributes.Public,
                 CallingConventions.HasThis,
                 new[] { typeof(string), typeof(string[]) });
@@ -272,7 +262,6 @@ namespace Lucene.Net.Expressions.JS
             int type = current.Type;
             string text = current.Text;
 
-
             switch (type)
             {
                 case JavascriptParser.AT_CALL:
@@ -296,12 +285,8 @@ namespace Lucene.Net.Expressions.JS
                             RecursiveCompile(current.GetChild(argument), typeof(double));
                         }
                         gen.Emit(OpCodes.Call, method);
-
-
-
                         break;
                     }
-
                 case JavascriptParser.NAMESPACE_ID:
                     {
                         int index;
@@ -322,39 +307,48 @@ namespace Lucene.Net.Expressions.JS
                         gen.Emit(OpCodes.Ldelem_Ref);
                         gen.Emit(OpCodes.Ldarg_1);
                         gen.Emit(OpCodes.Callvirt, DOUBLE_VAL_METHOD);
-
-
                         break;
                     }
-
                 case JavascriptParser.HEX:
                     {
-                        PushLong(expected, Convert.ToInt64(text.Substring(2), 16));
+                        PushLong(Convert.ToInt64(text, 16));
                         break;
                     }
-
                 case JavascriptParser.OCTAL:
                     {
-                        PushLong(expected, Convert.ToInt64(text.Substring(2), 8));
+                        PushLong(Convert.ToInt64(text, 8));
                         break;
                     }
 
                 case JavascriptParser.DECIMAL:
                     {
-                        gen.Emit(OpCodes.Ldc_R8, double.Parse(text));
-                        if (negate)
+                        //.NET Port. This is a bit hack-y but was needed since .NET can't perform bitwise ops on longs & doubles
+                        var bitwiseOps = new[]{ ">>","<<","&","~","|","^"};
+
+                        if (bitwiseOps.Any(s => sourceText.Contains(s)))
+                        {
+                            int val;
+                            if (int.TryParse(text, out val))
+                            {
+                                gen.Emit(OpCodes.Ldc_I4, val);
+                            }
+                            else
+                            {
+                                gen.Emit(OpCodes.Ldc_I8,long.Parse(text));
+                                gen.Emit(OpCodes.Conv_Ovf_U4_Un);
+                            }
+                        }
+                        else
                         {
-                            gen.Emit(OpCodes.Neg);
-                            negate = false;
+                            gen.Emit(OpCodes.Ldc_R8, double.Parse(text));
                         }
                         break;
                     }
 
                 case JavascriptParser.AT_NEGATE:
                     {
-                        negate = true;
                         RecursiveCompile(current.GetChild(0), typeof(double));
-
+                        gen.Emit(OpCodes.Neg);
                         break;
                     }
 
@@ -390,47 +384,45 @@ namespace Lucene.Net.Expressions.JS
 
                 case JavascriptParser.AT_BIT_SHL:
                     {
-                        PushShift(OpCodes.Shl, current, expected);
+                        PushShift(OpCodes.Shl, current);
                         break;
                     }
 
                 case JavascriptParser.AT_BIT_SHR:
                     {
-                        PushShift(OpCodes.Shr, current, expected);
+                        PushShift(OpCodes.Shr, current);
                         break;
                     }
 
                 case JavascriptParser.AT_BIT_SHU:
                     {
-                        PushShift(OpCodes.Shr_Un, current, expected);
+                        PushShift(OpCodes.Shr_Un, current);
                         break;
                     }
 
                 case JavascriptParser.AT_BIT_AND:
                     {
-                        PushBitwise(OpCodes.And, current, expected);
+                        PushBitwise(OpCodes.And, current);
                         break;
                     }
 
                 case JavascriptParser.AT_BIT_OR:
                     {
-                        PushBitwise(OpCodes.Or, current, expected);
+                        PushBitwise(OpCodes.Or, current);
                         break;
                     }
 
                 case JavascriptParser.AT_BIT_XOR:
                     {
-                        PushBitwise(OpCodes.Xor, current, expected);
+                        PushBitwise(OpCodes.Xor, current);
                         break;
                     }
 
                 case JavascriptParser.AT_BIT_NOT:
                     {
                         RecursiveCompile(current.GetChild(0), typeof(long));
-                        gen.Emit(OpCodes.Ldc_I4_M1);
-                        //dynamicType.Push(-1L);
-                        //dynamicType.VisitInsn(Opcodes.LXOR);
-                        //dynamicType.Cast(typeof(long), expected);
+                        gen.Emit(OpCodes.Not);
+                        gen.Emit(OpCodes.Conv_R8);
                         break;
                     }
 
@@ -442,7 +434,7 @@ namespace Lucene.Net.Expressions.JS
 
                 case JavascriptParser.AT_COMP_NEQ:
                     {
-                        //PushCond(OpCodes, current, expected);
+                        PushCondEq(OpCodes.Ceq, current, expected);
                         break;
                     }
 
@@ -460,73 +452,81 @@ namespace Lucene.Net.Expressions.JS
 
                 case JavascriptParser.AT_COMP_LTE:
                     {
-                        //PushCond(OpCodes.Clt | OpCodes.Ceq, current, expected);
+                        PushCondEq(OpCodes.Cgt, current, expected);
                         break;
                     }
 
                 case JavascriptParser.AT_COMP_GTE:
                     {
-                        //PushCond(GeneratorAdapter.GE, current, expected);
+                        PushCondEq(OpCodes.Clt, current, expected);
                         break;
                     }
 
                 case JavascriptParser.AT_BOOL_NOT:
                     {
-                        /*Label labelNotTrue = new Label();
-					Label labelNotReturn = new Label();
-					RecursiveCompile(current.GetChild(0), Type.INT_TYPE);
-					dynamicType.VisitJumpInsn(Opcodes.IFEQ, labelNotTrue);
-					PushBoolean(expected, false);
-					dynamicType.GoTo(labelNotReturn);
-					dynamicType.VisitLabel(labelNotTrue);
-					PushBoolean(expected, true);
-					dynamicType.VisitLabel(labelNotReturn);*/
+                        RecursiveCompile(current.GetChild(0), typeof(int));
+                        gen.Emit(OpCodes.Ldc_I4_0);
+                        gen.Emit(OpCodes.Ceq);
+                        gen.Emit(OpCodes.Conv_R8);
                         break;
                     }
 
                 case JavascriptParser.AT_BOOL_AND:
                     {
-                        /*Label andFalse = new Label();
-					Label andEnd = new Label();
-					RecursiveCompile(current.GetChild(0), Type.INT_TYPE);
-					dynamicType.VisitJumpInsn(Opcodes.IFEQ, andFalse);
-					RecursiveCompile(current.GetChild(1), Type.INT_TYPE);
-					dynamicType.VisitJumpInsn(Opcodes.IFEQ, andFalse);
-					PushBoolean(expected, true);
-					dynamicType.GoTo(andEnd);
-					dynamicType.VisitLabel(andFalse);
-					PushBoolean(expected, false);
-					dynamicType.VisitLabel(andEnd);*/
+
+                        RecursiveCompile(current.GetChild(0), typeof(int));
+                        gen.Emit(OpCodes.Ldc_I4_0);
+                        gen.Emit(OpCodes.Ceq);
+                        RecursiveCompile(current.GetChild(1), typeof(int));
+
+                        gen.Emit(OpCodes.Ldc_I4_0);
+                        gen.Emit(OpCodes.Ceq);
+
+                        gen.Emit(OpCodes.Or);
+
+                        gen.Emit(OpCodes.Ldc_I4_0);
+                        gen.Emit(OpCodes.Ceq);
+
+                        gen.Emit(OpCodes.Conv_R8);
+
+
                         break;
                     }
 
                 case JavascriptParser.AT_BOOL_OR:
                     {
-                        Label orTrue = new Label();
-                        Label orEnd = new Label();
-                        /*RecursiveCompile(current.GetChild(0), Type.INT_TYPE);
-					dynamicType.VisitJumpInsn(Opcodes.IFNE, orTrue);
-					RecursiveCompile(current.GetChild(1), Type.INT_TYPE);
-					dynamicType.VisitJumpInsn(Opcodes.IFNE, orTrue);
-					PushBoolean(expected, false);
-					dynamicType.GoTo(orEnd);
-					dynamicType.VisitLabel(orTrue);
-					PushBoolean(expected, true);
-					dynamicType.VisitLabel(orEnd);*/
+                        RecursiveCompile(current.GetChild(0), typeof(int));
+                        gen.Emit(OpCodes.Ldc_I4_0);
+                        gen.Emit(OpCodes.Ceq);
+                        gen.Emit(OpCodes.Ldc_I4_1);
+                        gen.Emit(OpCodes.Xor);
+                        RecursiveCompile(current.GetChild(1), typeof(int));
+
+                        gen.Emit(OpCodes.Ldc_I4_0);
+                        gen.Emit(OpCodes.Ceq);
+                        gen.Emit(OpCodes.Ldc_I4_1);
+                        gen.Emit(OpCodes.Xor);
+                        gen.Emit(OpCodes.Or);
+
+                        gen.Emit(OpCodes.Ldc_I4_1);
+                        gen.Emit(OpCodes.Ceq);
+
+                        gen.Emit(OpCodes.Conv_R8);
                         break;
                     }
 
                 case JavascriptParser.AT_COND_QUE:
                     {
-                        /*Label condFalse = new Label();
-					Label condEnd = new Label();
-					RecursiveCompile(current.GetChild(0), Type.INT_TYPE);
-					dynamicType.VisitJumpInsn(Opcodes.IFEQ, condFalse);
-					RecursiveCompile(current.GetChild(1), expected);
-					dynamicType.GoTo(condEnd);
-					dynamicType.VisitLabel(condFalse);
-					RecursiveCompile(current.GetChild(2), expected);
-					dynamicType.VisitLabel(condEnd);*/
+                        Label condFalse = gen.DefineLabel();
+                        Label condEnd = gen.DefineLabel();
+                        RecursiveCompile(current.GetChild(0), typeof(int));
+                        gen.Emit(OpCodes.Ldc_I4_0);
+                        gen.Emit(OpCodes.Beq,condFalse);
+                        RecursiveCompile(current.GetChild(1), expected);
+                        gen.Emit(OpCodes.Br_S,condEnd);
+                        gen.MarkLabel(condFalse);
+                        RecursiveCompile(current.GetChild(2), expected);
+                        gen.MarkLabel(condEnd);
                         break;
                     }
 
@@ -538,108 +538,70 @@ namespace Lucene.Net.Expressions.JS
 
         }
 
-        private void PushArith(OpCode op, ITree current, Type expected)
+        private void PushCondEq(OpCode opCode, ITree current, Type expected)
         {
-            PushBinaryOp(op, current, expected, typeof(double), typeof(double), typeof(double));
+            RecursiveCompile(current.GetChild(0), expected);
+            RecursiveCompile(current.GetChild(1), expected);
+            gen.Emit(opCode);
+            gen.Emit(OpCodes.Ldc_I4_1);
+            gen.Emit(OpCodes.Xor);
+            gen.Emit(OpCodes.Conv_R8);
         }
 
-        private void PushShift(OpCode op, ITree current, Type expected)
+        private void PushArith(OpCode op, ITree current, Type expected)
         {
-            PushBinaryOp(op, current, expected, typeof(long), typeof(int), typeof(long));
+            PushBinaryOp(op, current, typeof(double), typeof(double));
         }
 
-        private void PushBitwise(OpCode op, ITree current, Type expected)
+        private void PushShift(OpCode op, ITree current)
         {
-            PushBinaryOp(op, current, expected, typeof(long), typeof(long), typeof(long));
+            PushBinaryShiftOp(op, current, typeof(int), typeof(int));
         }
 
-        private void PushBinaryOp(OpCode op, ITree current, Type expected, Type arg1, Type arg2, Type returnType)
+        private void PushBinaryShiftOp(OpCode op, ITree current, Type arg1, Type arg2)
         {
             gen.Emit(OpCodes.Nop);
             RecursiveCompile(current.GetChild(0), arg1);
             RecursiveCompile(current.GetChild(1), arg2);
-            /* gen.Emit(OpCodes.Add, debugDoc, file, lineNum++);
-             gen.Emit(OpCodes.Stloc_0, debugDoc, file, lineNum++);
-             gen.Emit(OpCodes.Br_S, debugDoc, file, lineNum++);
-             gen.Emit(OpCodes.Ldloc_0, debugDoc, file, lineNum++);*/
             gen.Emit(op);
-            /*dynamicType.VisitInsn(op);
-			dynamicType.Cast(returnType, expected);*/
+            gen.Emit(OpCodes.Conv_R8);
+
         }
 
-        private void PushCond(OpCode @operator, ITree current, Type expected)
+        private void PushBitwise(OpCode op, ITree current)
         {
-            Label labelTrue = new Label();
-            Label labelReturn = new Label();
-            RecursiveCompile(current.GetChild(0), typeof(double));
-            RecursiveCompile(current.GetChild(1), typeof(double));
-            /*dynamicType.IfCmp(typeof(double), @operator, labelTrue);
-			PushBoolean(expected, false);
-			dynamicType.GoTo(labelReturn);
-			dynamicType.VisitLabel(labelTrue);
-			PushBoolean(expected, true);
-			dynamicType.VisitLabel(labelReturn);*/
+            PushBinaryOp(op, current, typeof(long), typeof(long));
         }
 
-        /*
-                private void PushBoolean(Type expected, bool truth)
-                {
-                    switch (expected.GetSort())
-                    {
-                        case Type.INT:
-                        {
-                            dynamicType.Push(truth);
-                            break;
-                        }
-
-                        case Type.LONG:
-                        {
-                            dynamicType.Push(truth ? 1L : 0L);
-                            break;
-                        }
+        private void PushBinaryOp(OpCode op, ITree current, Type arg1, Type arg2)
+        {
+            gen.Emit(OpCodes.Nop);
+            RecursiveCompile(current.GetChild(0), arg1);
+            RecursiveCompile(current.GetChild(1), arg2);
+            gen.Emit(op);
+            gen.Emit(OpCodes.Conv_R8);
+            
+        }
 
-                        case Type.DOUBLE:
-                        {
-                            dynamicType.Push(truth ? 1. : 0.);
-                            break;
-                        }
+        private void PushCond(OpCode opCode, ITree current, Type expected)
+        {
 
-                        default:
-                        {
-                            throw new InvalidOperationException("Invalid expected type: " + expected);
-                        }
-                    }
-                }
-        */
+            RecursiveCompile(current.GetChild(0), expected);
+            RecursiveCompile(current.GetChild(1), expected);
+            gen.Emit(opCode);
+            gen.Emit(OpCodes.Conv_R8);
+            
+        }
 
-        private void PushLong(Type expected, long i)
+        
+        private void PushLong(long i)
         {
-            /*switch (expected.GetSort())
-			{
-				case Type.INT:
-				{
-					dynamicType.Push((int)i);
-					break;
-				}
-
-				case Type.LONG:
-				{
-					dynamicType.Push(i);
-					break;
-				}
-
-				case Type.DOUBLE:
-				{
-					dynamicType.Push((double)i);
-					break;
-				}
-
-				default:
-				{
-					throw new InvalidOperationException("Invalid expected type: " + expected);
-				}
-			}*/
-            gen.Emit(OpCodes.Ldarg_0);
+            gen.Emit(OpCodes.Ldc_I8,i);
+            if (!sourceText.Contains("<<"))
+            {
+                gen.Emit(OpCodes.Conv_R8);
+            }
+            
         }
 
         private void EndCompile()
@@ -664,15 +626,6 @@ namespace Lucene.Net.Expressions.JS
             {
                 throw new ArgumentException(re.Message, re);
             }
-            catch (SystemException exception)
-            {
-                //TODO: Uncomment after implementing ParseException in QueryParsers
-                //if (exception.InnerException is ParseException)
-                //{
-                //    throw (ParseException)exception.InnerException;
-                //}
-                throw;
-            }
         }
 
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e2f872dc/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs b/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
index 80b8128..92aaac4 100644
--- a/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
+++ b/src/Lucene.Net.Expressions/JS/JavascriptLexer.cs
@@ -90,9 +90,10 @@ namespace Lucene.Net.Expressions.JS
 		// ANTLR GENERATED CODE: DO NOT EDIT
 		public override void DisplayRecognitionError(string[] tokenNames, RecognitionException re)
 		{
-            var message = string.Format("Unable to parse '{0}': unexpected character '{1}' at position ({2}).", re.Input
-                , (char)re.Character, re.CharPositionInLine);
-			throw new ParseException(message, re.CharPositionInLine);
+			string message = " unexpected character '" + (char)re.Character + "' at position (" + re.CharPositionInLine + ").";
+			ParseException parseException = new ParseException(message, re.CharPositionInLine);
+			
+			throw new SystemException(parseException.Message, parseException);
 		}
 
 		// delegates
@@ -927,166 +928,170 @@ loop3_break: ;
 		/// <exception cref="Org.Antlr.Runtime.RecognitionException"></exception>
 		public void MDECIMAL()
 		{
-			try
-			{
-				int _type = DECIMAL;
-				int _channel = TokenChannels.Default;
-				// src/java/org/apache/lucene/expressions/js/Javascript.g:347:5: ( DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )? | AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )? | DECIMALINTEGER ( EXPONENT )? )
-				int alt9 = 3;
-				alt9 = dfa9.Predict(input);
-				switch (alt9)
-				{
-					case 1:
-					{
-						// src/java/org/apache/lucene/expressions/js/Javascript.g:347:7: DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )?
-						MDECIMALINTEGER();
-						MAT_DOT();
-						// src/java/org/apache/lucene/expressions/js/Javascript.g:347:29: ( DECIMALDIGIT )*
-						while (true)
-						{
-							int alt4 = 2;
-							int LA4_0 = input.LA(1);
-							if (((LA4_0 >= '0' && LA4_0 <= '9')))
-							{
-								alt4 = 1;
-							}
-							switch (alt4)
-							{
-								case 1:
-								{
-									// src/java/org/apache/lucene/expressions/js/Javascript.g:
-									if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
-									{
-										input.Consume();
-									}
-									else
-									{
-										MismatchedSetException mse = new MismatchedSetException(null, input);
-										Recover(mse);
-										throw mse;
-									}
-									break;
-								}
-
-								default:
-								{
-									goto loop4_break;
-									break;
-								}
-							}
-loop4_continue: ;
-						}
-loop4_break: ;
-						// src/java/org/apache/lucene/expressions/js/Javascript.g:347:43: ( EXPONENT )?
-						int alt5 = 2;
-						int LA5_0 = input.LA(1);
-						if ((LA5_0 == 'E' || LA5_0 == 'e'))
-						{
-							alt5 = 1;
-						}
-						switch (alt5)
-						{
-							case 1:
-							{
-								// src/java/org/apache/lucene/expressions/js/Javascript.g:347:43: EXPONENT
-								MEXPONENT();
-								break;
-							}
-						}
-						break;
-					}
-
-					case 2:
-					{
-						// src/java/org/apache/lucene/expressions/js/Javascript.g:348:7: AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )?
-						MAT_DOT();
-						// src/java/org/apache/lucene/expressions/js/Javascript.g:348:14: ( DECIMALDIGIT )+
-						int cnt6 = 0;
-						while (true)
-						{
-							int alt6 = 2;
-							int LA6_0 = input.LA(1);
-							if (((LA6_0 >= '0' && LA6_0 <= '9')))
-							{
-								alt6 = 1;
-							}
-							switch (alt6)
-							{
-								case 1:
-								{
-									// src/java/org/apache/lucene/expressions/js/Javascript.g:
-									if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
-									{
-										input.Consume();
-									}
-									else
-									{
-										MismatchedSetException mse = new MismatchedSetException(null, input);
-										Recover(mse);
-										throw mse;
-									}
-									break;
-								}
-
-								default:
-								{
-									if (cnt6 >= 1)
-									{
-										goto loop6_break;
-									}
-									EarlyExitException eee = new EarlyExitException(6, input);
-									throw eee;
-								}
-							}
-							cnt6++;
-loop6_continue: ;
-						}
-loop6_break: ;
-						// src/java/org/apache/lucene/expressions/js/Javascript.g:348:28: ( EXPONENT )?
-						int alt7 = 2;
-						int LA7_0 = input.LA(1);
-						if ((LA7_0 == 'E' || LA7_0 == 'e'))
-						{
-							alt7 = 1;
-						}
-						switch (alt7)
-						{
-							case 1:
-							{
-								// src/java/org/apache/lucene/expressions/js/Javascript.g:348:28: EXPONENT
-								MEXPONENT();
-								break;
-							}
-						}
-						break;
-					}
-
-					case 3:
-					{
-						// src/java/org/apache/lucene/expressions/js/Javascript.g:349:7: DECIMALINTEGER ( EXPONENT )?
-						MDECIMALINTEGER();
-						// src/java/org/apache/lucene/expressions/js/Javascript.g:349:22: ( EXPONENT )?
-						int alt8 = 2;
-						int LA8_0 = input.LA(1);
-						if ((LA8_0 == 'E' || LA8_0 == 'e'))
-						{
-							alt8 = 1;
-						}
-						switch (alt8)
-						{
-							case 1:
-							{
-								// src/java/org/apache/lucene/expressions/js/Javascript.g:349:22: EXPONENT
-								MEXPONENT();
-								break;
-							}
-						}
-						break;
-					}
-				}
-				state.type = _type;
-				state.channel = _channel;
-			}
+		    try
+		    {
+		        int type = DECIMAL;
+		        int channel = TokenChannels.Default;
+		        // src/java/org/apache/lucene/expressions/js/Javascript.g:347:5: ( DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )? | AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )? | DECIMALINTEGER ( EXPONENT )? )
+		        int alt9 = 3;
+		        alt9 = dfa9.Predict(input);
+		        switch (alt9)
+		        {
+		            case 1:
+		            {
+		                // src/java/org/apache/lucene/expressions/js/Javascript.g:347:7: DECIMALINTEGER AT_DOT ( DECIMALDIGIT )* ( EXPONENT )?
+		                MDECIMALINTEGER();
+		                MAT_DOT();
+		                // src/java/org/apache/lucene/expressions/js/Javascript.g:347:29: ( DECIMALDIGIT )*
+		                while (true)
+		                {
+		                    int alt4 = 2;
+		                    int LA4_0 = input.LA(1);
+		                    if (((LA4_0 >= '0' && LA4_0 <= '9')))
+		                    {
+		                        alt4 = 1;
+		                    }
+		                    switch (alt4)
+		                    {
+		                        case 1:
+		                        {
+		                            // src/java/org/apache/lucene/expressions/js/Javascript.g:
+		                            if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
+		                            {
+		                                input.Consume();
+		                            }
+		                            else
+		                            {
+		                                MismatchedSetException mse = new MismatchedSetException(null, input);
+		                                Recover(mse);
+		                                throw mse;
+		                            }
+		                            break;
+		                        }
+
+		                        default:
+		                        {
+		                            goto loop4_break;
+		                            break;
+		                        }
+		                    }
+		                    loop4_continue:
+		                    ;
+		                }
+		                loop4_break:
+		                ;
+		                // src/java/org/apache/lucene/expressions/js/Javascript.g:347:43: ( EXPONENT )?
+		                int alt5 = 2;
+		                int LA5_0 = input.LA(1);
+		                if ((LA5_0 == 'E' || LA5_0 == 'e'))
+		                {
+		                    alt5 = 1;
+		                }
+		                switch (alt5)
+		                {
+		                    case 1:
+		                    {
+		                        // src/java/org/apache/lucene/expressions/js/Javascript.g:347:43: EXPONENT
+		                        MEXPONENT();
+		                        break;
+		                    }
+		                }
+		                break;
+		            }
+
+		            case 2:
+		            {
+		                // src/java/org/apache/lucene/expressions/js/Javascript.g:348:7: AT_DOT ( DECIMALDIGIT )+ ( EXPONENT )?
+		                MAT_DOT();
+		                // src/java/org/apache/lucene/expressions/js/Javascript.g:348:14: ( DECIMALDIGIT )+
+		                int cnt6 = 0;
+		                while (true)
+		                {
+		                    int alt6 = 2;
+		                    int LA6_0 = input.LA(1);
+		                    if (((LA6_0 >= '0' && LA6_0 <= '9')))
+		                    {
+		                        alt6 = 1;
+		                    }
+		                    switch (alt6)
+		                    {
+		                        case 1:
+		                        {
+		                            // src/java/org/apache/lucene/expressions/js/Javascript.g:
+		                            if ((input.LA(1) >= '0' && input.LA(1) <= '9'))
+		                            {
+		                                input.Consume();
+		                            }
+		                            else
+		                            {
+		                                MismatchedSetException mse = new MismatchedSetException(null, input);
+		                                Recover(mse);
+		                                throw mse;
+		                            }
+		                            break;
+		                        }
+
+		                        default:
+		                        {
+		                            if (cnt6 >= 1)
+		                            {
+		                                goto loop6_break;
+		                            }
+		                            EarlyExitException eee = new EarlyExitException(6, input);
+		                            throw eee;
+		                        }
+		                    }
+		                    cnt6++;
+		                    loop6_continue:
+		                    ;
+		                }
+		                loop6_break:
+		                ;
+		                // src/java/org/apache/lucene/expressions/js/Javascript.g:348:28: ( EXPONENT )?
+		                int alt7 = 2;
+		                int LA7_0 = input.LA(1);
+		                if ((LA7_0 == 'E' || LA7_0 == 'e'))
+		                {
+		                    alt7 = 1;
+		                }
+		                switch (alt7)
+		                {
+		                    case 1:
+		                    {
+		                        // src/java/org/apache/lucene/expressions/js/Javascript.g:348:28: EXPONENT
+		                        MEXPONENT();
+		                        break;
+		                    }
+		                }
+		                break;
+		            }
+
+		            case 3:
+		            {
+		                // src/java/org/apache/lucene/expressions/js/Javascript.g:349:7: DECIMALINTEGER ( EXPONENT )?
+		                MDECIMALINTEGER();
+		                // src/java/org/apache/lucene/expressions/js/Javascript.g:349:22: ( EXPONENT )?
+		                int alt8 = 2;
+		                int LA8_0 = input.LA(1);
+		                if ((LA8_0 == 'E' || LA8_0 == 'e'))
+		                {
+		                    alt8 = 1;
+		                }
+		                switch (alt8)
+		                {
+		                    case 1:
+		                    {
+		                        // src/java/org/apache/lucene/expressions/js/Javascript.g:349:22: EXPONENT
+		                        MEXPONENT();
+		                        break;
+		                    }
+		                }
+		                break;
+		            }
+		        }
+		        state.type = type;
+		        state.channel = channel;
+		    }
 			finally
 			{
 			}
@@ -2096,9 +2101,9 @@ loop16_break: ;
 
 		internal static readonly string DFA9_eofS = "\x7\uffff";
 
-		internal static readonly string DFA9_minS = "\x3\x38\x3\uffff\x1\x38";
+		internal static readonly string DFA9_minS = "\x3\x30\x3\uffff\x1\x30";
 
-		internal static readonly string DFA9_maxS = "\x1\x47\x1\x38\x1\x47\x3\uffff\x1\x47";
+		internal static readonly string DFA9_maxS = "\x1\x49\x1\x30\x1\x49\x3\uffff\x1\x49";
 
 		internal static readonly string DFA9_acceptS = "\x3\uffff\x1\x2\x1\x3\x1\x1\x1\uffff";
 
@@ -2112,11 +2117,9 @@ loop16_break: ;
 
 		internal static readonly short[] DFA9_eof = DFA.UnpackEncodedString(DFA9_eofS);
 
-		internal static readonly char[] DFA9_min = DFA.UnpackEncodedStringToUnsignedChars
-			(DFA9_minS);
+	    internal static readonly char[] DFA9_min = {'.','.','.','?','?','?','.'}; //DFA.UnpackEncodedStringToUnsignedChars(DFA9_minS);
 
-		internal static readonly char[] DFA9_max = DFA.UnpackEncodedStringToUnsignedChars
-			(DFA9_maxS);
+	    internal static readonly char[] DFA9_max = {'9', '.', '9', '?', '?', '?', '9'}; //DFA.UnpackEncodedStringToUnsignedChars(DFA9_maxS);
 
 		internal static readonly short[] DFA9_accept = DFA.UnpackEncodedString(DFA9_acceptS
 			);
@@ -2144,13 +2147,13 @@ loop16_break: ;
 				this._enclosing = _enclosing;
 				this.recognizer = recognizer;
 				this.decisionNumber = 9;
-				this.eot = JavascriptLexer.DFA9_eot;
-				this.eof = JavascriptLexer.DFA9_eof;
-				this.min = JavascriptLexer.DFA9_min;
-				this.max = JavascriptLexer.DFA9_max;
-				this.accept = JavascriptLexer.DFA9_accept;
-				this.special = JavascriptLexer.DFA9_special;
-				this.transition = JavascriptLexer.DFA9_transition;
+				this.eot = DFA9_eot;
+				this.eof = DFA9_eof;
+				this.min = DFA9_min;
+				this.max = DFA9_max;
+				this.accept = DFA9_accept;
+				this.special = DFA9_special;
+				this.transition = DFA9_transition;
 			}
 
 			public override string Description
@@ -2168,11 +2171,9 @@ loop16_break: ;
 
     public class ParseException:Exception
     {
-        private readonly int _charPositionInLine;
-
-        public ParseException(string message, int charPositionInLine) : base(message)
+        public ParseException(string message, int charPositionInLine)
         {
-            _charPositionInLine = charPositionInLine;
+            
         }
     }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e2f872dc/src/Lucene.Net.Expressions/SimpleBindings.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Expressions/SimpleBindings.cs b/src/Lucene.Net.Expressions/SimpleBindings.cs
index 92dfc9f..78f97d6 100644
--- a/src/Lucene.Net.Expressions/SimpleBindings.cs
+++ b/src/Lucene.Net.Expressions/SimpleBindings.cs
@@ -6,127 +6,127 @@ using Lucene.Net.Search;
 
 namespace Lucene.Net.Expressions
 {
-	/// <summary>
-	/// Simple class that binds expression variable names to
-	/// <see cref="Lucene.Net.Search.SortField">Lucene.Net.Search.SortField
-	/// 	</see>
-	/// s
-	/// or other
-	/// <see cref="Expression">Expression</see>
-	/// s.
-	/// <p>
-	/// Example usage:
-	/// <pre class="prettyprint">
-	/// SimpleBindings bindings = new SimpleBindings();
-	/// // document's text relevance score
-	/// bindings.add(new SortField("_score", SortField.Type.SCORE));
-	/// // integer NumericDocValues field (or from FieldCache)
-	/// bindings.add(new SortField("popularity", SortField.Type.INT));
-	/// // another expression
-	/// bindings.add("recency", myRecencyExpression);
-	/// // create a sort field in reverse order
-	/// Sort sort = new Sort(expr.getSortField(bindings, true));
-	/// </pre>
-	/// </summary>
-	/// <lucene.experimental></lucene.experimental>
-	public sealed class SimpleBindings : Bindings
-	{
-		internal readonly IDictionary<string, object> map = new Dictionary<string, object
-			>();
+    /// <summary>
+    /// Simple class that binds expression variable names to
+    /// <see cref="Lucene.Net.Search.SortField">Lucene.Net.Search.SortField
+    /// 	</see>
+    /// s
+    /// or other
+    /// <see cref="Expression">Expression</see>
+    /// s.
+    /// <p>
+    /// Example usage:
+    /// <pre class="prettyprint">
+    /// SimpleBindings bindings = new SimpleBindings();
+    /// // document's text relevance score
+    /// bindings.add(new SortField("_score", SortField.Type.SCORE));
+    /// // integer NumericDocValues field (or from FieldCache)
+    /// bindings.add(new SortField("popularity", SortField.Type.INT));
+    /// // another expression
+    /// bindings.add("recency", myRecencyExpression);
+    /// // create a sort field in reverse order
+    /// Sort sort = new Sort(expr.getSortField(bindings, true));
+    /// </pre>
+    /// </summary>
+    /// <lucene.experimental></lucene.experimental>
+    public sealed class SimpleBindings : Bindings
+    {
+        internal readonly IDictionary<string, object> map = new Dictionary<string, object
+            >();
 
-	    /// <summary>Adds a SortField to the bindings.</summary>
-		/// <remarks>
-		/// Adds a SortField to the bindings.
-		/// <p>
-		/// This can be used to reference a DocValuesField, a field from
-		/// FieldCache, the document's score, etc.
-		/// </remarks>
-		public void Add(SortField sortField)
-		{
-			map[sortField.Field] = sortField;
-		}
+        /// <summary>Adds a SortField to the bindings.</summary>
+        /// <remarks>
+        /// Adds a SortField to the bindings.
+        /// <p>
+        /// This can be used to reference a DocValuesField, a field from
+        /// FieldCache, the document's score, etc.
+        /// </remarks>
+        public void Add(SortField sortField)
+        {
+            map[sortField.Field] = sortField;
+        }
 
-		/// <summary>Adds an Expression to the bindings.</summary>
-		/// <remarks>
-		/// Adds an Expression to the bindings.
-		/// <p>
-		/// This can be used to reference expressions from other expressions.
-		/// </remarks>
-		public void Add(string name, Expression expression)
-		{
-			map[name] = expression;
-		}
+        /// <summary>Adds an Expression to the bindings.</summary>
+        /// <remarks>
+        /// Adds an Expression to the bindings.
+        /// <p>
+        /// This can be used to reference expressions from other expressions.
+        /// </remarks>
+        public void Add(string name, Expression expression)
+        {
+            map[name] = expression;
+        }
 
-		public override ValueSource GetValueSource(string name)
-		{
-		    object o;
-			if (!map.TryGetValue(name, out o))
-			{
-				throw new ArgumentException("Invalid reference '" + name + "'");
-			}
+        public override ValueSource GetValueSource(string name)
+        {
 
-		    var expression = o as Expression;
-		    if (expression != null)
-		    {
-		        return expression.GetValueSource(this);
-		    }
+            object o;
+            //.NET Port. Directly looking up a missing key will throw a KeyNotFoundException
+            if (!map.TryGetValue(name, out o))
+            {
+                throw new ArgumentException("Invalid reference '" + name + "'");
+            }
+            var expression = o as Expression;
+            if (expression != null)
+            {
+                return expression.GetValueSource(this);
+            }
+            SortField field = (SortField)o;
+            switch (field.Type)
+            {
+                case SortField.Type_e.INT:
+                    {
+                        return new IntFieldSource(field.Field, (FieldCache.IIntParser)field.Parser);
+                    }
 
-		    SortField field = (SortField)o;
-			switch (field.Type)
-			{
-				case SortField.Type_e.INT:
-				{
-					return new IntFieldSource(field.Field, (FieldCache.IIntParser) field.Parser);
-				}
+                case SortField.Type_e.LONG:
+                    {
+                        return new LongFieldSource(field.Field, (FieldCache.ILongParser)field.Parser);
+                    }
 
-				case SortField.Type_e.LONG:
-				{
-					return new LongFieldSource(field.Field, (FieldCache.ILongParser)field.Parser);
-				}
+                case SortField.Type_e.FLOAT:
+                    {
+                        return new FloatFieldSource(field.Field, (FieldCache.IFloatParser)field.Parser);
+                    }
 
-				case SortField.Type_e.FLOAT:
-				{
-					return new FloatFieldSource(field.Field, (FieldCache.IFloatParser)field.Parser);
-				}
+                case SortField.Type_e.DOUBLE:
+                    {
+                        return new DoubleFieldSource(field.Field, (FieldCache.IDoubleParser)field.Parser);
+                    }
 
-				case SortField.Type_e.DOUBLE:
-				{
-					return new DoubleFieldSource(field.Field, (FieldCache.IDoubleParser)field.Parser);
-				}
+                case SortField.Type_e.SCORE:
+                    {
+                        return GetScoreValueSource();
+                    }
 
-				case SortField.Type_e.SCORE:
-				{
-					return GetScoreValueSource();
-				}
+                default:
+                    {
+                        throw new NotSupportedException();
+                    }
+            }
 
-				default:
-				{
-					throw new NotSupportedException();
-				}
-			}
-		}
+        }
 
-		/// <summary>Traverses the graph of bindings, checking there are no cycles or missing references
-		/// 	</summary>
-		/// <exception cref="System.ArgumentException">if the bindings is inconsistent</exception>
-		public void Validate()
-		{
-			foreach (object o in map.Values)
-			{
-				if (o is Expression)
-				{
-					Expression expr = (Expression)o;
-					try
-					{
-						expr.GetValueSource(this);
-					}
-					catch (StackOverflowException)
-					{
-						throw new ArgumentException("Recursion Error: Cycle detected originating in (" + 
-							expr.sourceText + ")");
-					}
-				}
-			}
-		}
-	}
+        /// <summary>Traverses the graph of bindings, checking there are no cycles or missing references
+        /// 	</summary>
+        /// <exception cref="System.ArgumentException">if the bindings is inconsistent</exception>
+        public void Validate()
+        {
+            foreach (object o in map.Values)
+            {
+                if (o is Expression)
+                {
+                    Expression expr = (Expression)o;
+                    try
+                    {
+                        expr.GetValueSource(this);
+                    }
+                    catch (StackOverflowException)
+                    {
+                        throw new ArgumentException("Recursion Error: Cycle detected originating in (" + expr.sourceText + ")");
+                    }
+                }
+            }
+        }
+    }
 }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e2f872dc/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs b/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs
index 07b2fa9..71f8465 100644
--- a/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs
+++ b/src/Lucene.Net.Tests.Expressions/JS/TestJavascriptOperations.cs
@@ -74,7 +74,8 @@ namespace Lucene.Net.Tests.Expressions.JS
 			AssertEvaluatesTo("10/5/2", 1);
 			AssertEvaluatesTo("(27/9)/3", 1);
 			AssertEvaluatesTo("27/(9/3)", 9);
-			AssertEvaluatesTo("1/0", 9223372036854775807L);
+            //.NET Port division overflow cast to double evals to long.MinValue
+            AssertEvaluatesTo("1/0", -9223372036854775808);
 		}
 
 		[Test]
@@ -177,12 +178,12 @@ namespace Lucene.Net.Tests.Expressions.JS
 		public virtual void TestBoolNotOperation()
 		{
 			AssertEvaluatesTo("!1", 0);
-			AssertEvaluatesTo("!!1", 1);
+            AssertEvaluatesTo("!!1", 1);
 			AssertEvaluatesTo("!0", 1);
-			AssertEvaluatesTo("!!0", 0);
-			AssertEvaluatesTo("!-1", 0);
-			AssertEvaluatesTo("!2", 0);
-			AssertEvaluatesTo("!-2", 0);
+            AssertEvaluatesTo("!!0", 0);
+            AssertEvaluatesTo("!-1", 0);
+            AssertEvaluatesTo("!2", 0);
+            AssertEvaluatesTo("!-2", 0);
 		}
 
 		[Test]
@@ -240,7 +241,7 @@ namespace Lucene.Net.Tests.Expressions.JS
 			AssertEvaluatesTo("4195 << 6", 268480);
 			AssertEvaluatesTo("4195 << 70", 268480);
 			AssertEvaluatesTo("-4195 << 70", -268480);
-			AssertEvaluatesTo("-15 << 62", 4611686018427387904L);
+			AssertEvaluatesTo("-15 << 62", 1073741824);
 		}
 
 		[Test]
@@ -266,13 +267,14 @@ namespace Lucene.Net.Tests.Expressions.JS
 			AssertEvaluatesTo("2 >>> 1", 1);
 			AssertEvaluatesTo("-1 >>> 37", 134217727);
 			AssertEvaluatesTo("-2 >>> 62", 3);
-			AssertEvaluatesTo("-5 >>> 33", 2147483647);
+            //.NET Port. CLR returns different values for unsigned shift ops
+			AssertEvaluatesTo("-5 >>> 33", 2147483645);
 			AssertEvaluatesTo("536960 >>> 7", 4195);
 			AssertEvaluatesTo("16780 >>> 66", 4195);
 			AssertEvaluatesTo("268480 >>> 6", 4195);
 			AssertEvaluatesTo("268480 >>> 70", 4195);
-			AssertEvaluatesTo("-268480 >>> 102", 67108863);
-			AssertEvaluatesTo("2147483648 >>> 1", 1073741824);
+			AssertEvaluatesTo("-268480 >>> 102", 67104669);
+            AssertEvaluatesTo("2147483648 >>> 1", 1073741824);
 		}
 
 		[Test]
@@ -342,8 +344,8 @@ namespace Lucene.Net.Tests.Expressions.JS
 			AssertEvaluatesTo("0x1", 1);
 			AssertEvaluatesTo("0xF", 15);
 			AssertEvaluatesTo("0x1234ABCDEF", 78193085935L);
-			AssertEvaluatesTo("1 << 0x1", 1 << unchecked((int)(0x1)));
-			AssertEvaluatesTo("1 << 0xA", 1 << unchecked((int)(0xA)));
+			AssertEvaluatesTo("1 << 0x1", 1 << (0x1));
+			AssertEvaluatesTo("1 << 0xA", 1 << (0xA));
 			AssertEvaluatesTo("0x1 << 2", unchecked((int)(0x1)) << 2);
 			AssertEvaluatesTo("0xA << 2", unchecked((int)(0xA)) << 2);
 		}

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/e2f872dc/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs b/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs
index dfb6c95..afe2c51 100644
--- a/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs
+++ b/src/Lucene.Net.Tests.Expressions/TestExpressionValidation.cs
@@ -60,7 +60,7 @@ namespace Lucene.Net.Tests.Expressions
 			}
 		}
 
-        [Test, Ignore("Causing the runner to crash. revisit after all tests are fixed")]
+        [Test,Ignore("StackOverflowException can't be caught in .NET")]
 		public virtual void TestSelfRecursion()
 		{
 			SimpleBindings bindings = new SimpleBindings();
@@ -76,7 +76,7 @@ namespace Lucene.Net.Tests.Expressions
 			}
 		}
 
-		[Test, Ignore("Causing the runner to crash. revisit after all tests are fixed")]
+        [Test, Ignore("StackOverflowException can't be caught in .NET")]
 		public virtual void TestCoRecursion()
 		{
 			SimpleBindings bindings = new SimpleBindings();
@@ -93,7 +93,7 @@ namespace Lucene.Net.Tests.Expressions
 			}
 		}
 
-        [Test, Ignore("Causing the runner to crash. revisit after all tests are fixed")]
+        [Test, Ignore("StackOverflowException can't be caught in .NET")]
 		public virtual void TestCoRecursion2()
 		{
 			SimpleBindings bindings = new SimpleBindings();
@@ -111,7 +111,7 @@ namespace Lucene.Net.Tests.Expressions
 			}
 		}
 
-        [Test, Ignore("Causing the runner to crash. revisit after all tests are fixed")]
+        [Test, Ignore("StackOverflowException can't be caught in .NET")]
 		public virtual void TestCoRecursion3()
 		{
 			SimpleBindings bindings = new SimpleBindings();
@@ -129,7 +129,7 @@ namespace Lucene.Net.Tests.Expressions
 			}
 		}
 
-        [Test, Ignore("Causing the runner to crash. revisit after all tests are fixed")]
+        [Test, Ignore("StackOverflowException can't be caught in .NET")]
 		public virtual void TestCoRecursion4()
 		{
 			SimpleBindings bindings = new SimpleBindings();


Mime
View raw message