using Lucene.Net.Expressions.JS;
using Lucene.Net.Search;
using Lucene.Net.Util;
using NUnit.Framework;
using System;

namespace Lucene.Net.Expressions
{
    /*
	 * Licensed to the Apache Software Foundation (ASF) under one or more
	 * contributor license agreements.  See the NOTICE file distributed with
	 * this work for additional information regarding copyright ownership.
	 * The ASF licenses this file to You under the Apache License, Version 2.0
	 * (the "License"); you may not use this file except in compliance with
	 * the License.  You may obtain a copy of the License at
	 *
	 *     http://www.apache.org/licenses/LICENSE-2.0
	 *
	 * Unless required by applicable law or agreed to in writing, software
	 * distributed under the License is distributed on an "AS IS" BASIS,
	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	 * See the License for the specific language governing permissions and
	 * limitations under the License.
	 */

    /// <summary>Tests validation of bindings</summary>
    public class TestExpressionValidation : LuceneTestCase
	{
		[Test]
		public virtual void TestValidExternals()
		{
			SimpleBindings bindings = new SimpleBindings();
			bindings.Add(new SortField("valid0", SortFieldType.INT32));
			bindings.Add(new SortField("valid1", SortFieldType.INT32));
			bindings.Add(new SortField("valid2", SortFieldType.INT32));
			bindings.Add(new SortField("_score", SortFieldType.SCORE));
			bindings.Add("valide0", JavascriptCompiler.Compile("valid0 - valid1 + valid2 + _score"
				));
			bindings.Validate();
			bindings.Add("valide1", JavascriptCompiler.Compile("valide0 + valid0"));
			bindings.Validate();
			bindings.Add("valide2", JavascriptCompiler.Compile("valide0 * valide1"));
			bindings.Validate();
		}

		[Test]
		public virtual void TestInvalidExternal()
		{
			SimpleBindings bindings = new SimpleBindings();
			bindings.Add(new SortField("valid", SortFieldType.INT32));
			bindings.Add("invalid", JavascriptCompiler.Compile("badreference"));
			try
			{
				bindings.Validate();
                Assert.Fail("didn't get expected exception");
			}
			catch (ArgumentException expected)
			{
                Assert.IsTrue(expected.Message.Contains("Invalid reference"));
			}
		}

		[Test]
		public virtual void TestInvalidExternal2()
		{
			SimpleBindings bindings = new SimpleBindings();
			bindings.Add(new SortField("valid", SortFieldType.INT32));
			bindings.Add("invalid", JavascriptCompiler.Compile("valid + badreference"));
			try
			{
				bindings.Validate();
                Assert.Fail("didn't get expected exception");
			}
			catch (ArgumentException expected)
			{
                Assert.IsTrue(expected.Message.Contains("Invalid reference"));
			}
		}

        [Test,Ignore("StackOverflowException can't be caught in .NET")]
		public virtual void TestSelfRecursion()
		{
			SimpleBindings bindings = new SimpleBindings();
			bindings.Add("cycle0", JavascriptCompiler.Compile("cycle0"));
			try
			{
				bindings.Validate();
                Assert.Fail("didn't get expected exception");
			}
			catch (ArgumentException expected)
			{
                Assert.IsTrue(expected.Message.Contains("Cycle detected"));
			}
		}

        [Test, Ignore("StackOverflowException can't be caught in .NET")]
		public virtual void TestCoRecursion()
		{
			SimpleBindings bindings = new SimpleBindings();
			bindings.Add("cycle0", JavascriptCompiler.Compile("cycle1"));
			bindings.Add("cycle1", JavascriptCompiler.Compile("cycle0"));
			try
			{
				bindings.Validate();
                Assert.Fail("didn't get expected exception");
			}
			catch (ArgumentException expected)
			{
                Assert.IsTrue(expected.Message.Contains("Cycle detected"));
			}
		}

        [Test, Ignore("StackOverflowException can't be caught in .NET")]
		public virtual void TestCoRecursion2()
		{
			SimpleBindings bindings = new SimpleBindings();
			bindings.Add("cycle0", JavascriptCompiler.Compile("cycle1"));
			bindings.Add("cycle1", JavascriptCompiler.Compile("cycle2"));
			bindings.Add("cycle2", JavascriptCompiler.Compile("cycle0"));
			try
			{
				bindings.Validate();
                Assert.Fail("didn't get expected exception");
			}
			catch (ArgumentException expected)
			{
                Assert.IsTrue(expected.Message.Contains("Cycle detected"));
			}
		}

        [Test, Ignore("StackOverflowException can't be caught in .NET")]
		public virtual void TestCoRecursion3()
		{
			SimpleBindings bindings = new SimpleBindings();
			bindings.Add("cycle0", JavascriptCompiler.Compile("100"));
			bindings.Add("cycle1", JavascriptCompiler.Compile("cycle0 + cycle2"));
			bindings.Add("cycle2", JavascriptCompiler.Compile("cycle0 + cycle1"));
			try
			{
				bindings.Validate();
                Assert.Fail("didn't get expected exception");
			}
			catch (ArgumentException expected)
			{
                Assert.IsTrue(expected.Message.Contains("Cycle detected"));
			}
		}

        [Test, Ignore("StackOverflowException can't be caught in .NET")]
		public virtual void TestCoRecursion4()
		{
			SimpleBindings bindings = new SimpleBindings();
			bindings.Add("cycle0", JavascriptCompiler.Compile("100"));
			bindings.Add("cycle1", JavascriptCompiler.Compile("100"));
			bindings.Add("cycle2", JavascriptCompiler.Compile("cycle1 + cycle0 + cycle3"));
			bindings.Add("cycle3", JavascriptCompiler.Compile("cycle0 + cycle1 + cycle2"));
			try
			{
				bindings.Validate();
                Assert.Fail("didn't get expected exception");
			}
			catch (ArgumentException expected)
			{
                Assert.IsTrue(expected.Message.Contains("Cycle detected"));
			}
		}
	}
}
