source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/ExecExpressionTests.cs @ 14392

using HeuristicLab.Algorithms.PushGP;
using HeuristicLab.Algorithms.PushGP.Expressions;
using HeuristicLab.Algorithms.PushGP.Stack;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace HeuristicLab.Tests.Interpreter.Expressions
{
    [TestClass]
    public class ExecExpressionTests : CommonTests<Expression>
    {
        protected override string TypeName { get { return "EXEC"; } }

        protected override IStack<Expression> Stack { get { return interpreter.ExecStack; } }

        protected override void Test(Expression expression)
        {
            this.interpreter.InterpretAsync(expression, true).Wait();
        }

        [TestMethod]
        public void TestIfTrue()
        {
            interpreter.BooleanStack.Push(true);
            interpreter.Interpret("( EXEC.IF WAHR FALSCH )");

            Assert.AreEqual("WAHR", interpreter.NameStack.Top);
            this.TestStackCounts(nameStack: 1);
        }

        [TestMethod]
        public void TestIfFalse()
        {
            interpreter.BooleanStack.Push(false);
            interpreter.Interpret("( EXEC.IF WAHR FALSCH )");

            Assert.AreEqual("FALSCH", interpreter.NameStack.Top);
            this.TestStackCounts(nameStack: 1);
        }

        [TestMethod]
        public void TestK()
        {
            var first = Parser.Parse("A");
            var second = Parser.Parse("B");
            var third = Parser.Parse("C");

            interpreter.ExecStack.Push(third, second, first);
            this.Test(new ExecKExpression());

            Assert.AreEqual(first, interpreter.ExecStack.Top);
            Assert.AreEqual(third, interpreter.ExecStack.Bottom);
            this.TestStackCounts(execStack: 2);
        }

        [TestMethod]
        public void TestS()
        {
            var first = Parser.Parse("A");
            var second = Parser.Parse("B");
            var third = Parser.Parse("C");
            var result = Parser.Parse("( B C )");

            interpreter.ExecStack.Push(third, second, first);
            this.Test(new ExecSExpression());

            Assert.AreEqual(result, interpreter.ExecStack.ReverseElementAt(2));
            Assert.AreEqual(third, interpreter.ExecStack.ReverseElementAt(1));
            Assert.AreEqual(first, interpreter.ExecStack.Top);
            this.TestStackCounts(execStack: 3);
        }

        [TestMethod]
        public void TestY()
        {
            var first = Parser.Parse("A");
            var result = Parser.Parse("( EXEC.Y A )");

            interpreter.ExecStack.Push(first);
            this.Test(new ExecYExpression());

            Assert.AreEqual(first, interpreter.ExecStack.Top);
            Assert.AreEqual(result, interpreter.ExecStack.ReverseElementAt(1));
            this.TestStackCounts(execStack: 2);
        }

        [TestMethod]
        public void TestNestedDoRange()
        {
            interpreter.Interpret("( 0 2 EXEC.DO*RANGE ( 1 INTEGER.+ 0 3 EXEC.DO*RANGE ( 1 INTEGER.+ INTEGER.* ) INTEGER.+ )");

            Assert.AreEqual(144, interpreter.IntegerStack.Top);
            this.TestStackCounts(integerStack: 1);
        }

        [TestMethod]
        public void TestNestedDoCount()
        {
            interpreter.Interpret("( 2 EXEC.DO*COUNT ( 1 INTEGER.+ 3 EXEC.DO*COUNT ( 1 INTEGER.+ INTEGER.* ) INTEGER.+ )");

            Assert.AreEqual(144, interpreter.IntegerStack.Top);
            this.TestStackCounts(integerStack: 1);
        }

        [TestMethod]
        public void TestNestedDoTimes()
        {
            interpreter.Interpret("( 3 EXEC.DO*TIMES ( 2 3 EXEC.DO*TIMES ( 2 INTEGER.* ) INTEGER.+ )");

            Assert.AreEqual(128, interpreter.IntegerStack.Top);
            this.TestStackCounts(integerStack: 1);
        }

        protected override Expression[] GetValues(int count)
        {
            var values = new Expression[count];

            for (var i = 0; i < count; i++)
            {
                values[i] = new CodeNoopExpression();
            }

            return values;
        }

        protected override Expression[] Get2Different()
        {
            return new Expression[]
            {
                new CodeNoopExpression(),
                new CodeNullExpression()
            };
        }

        protected override void CheckOtherStacksAreEmpty()
        {
            this.TestStackCounts(execStack: null);
        }
    }
}