source: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Tests/Interpreter/Expressions/CommonTests.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
{

    public abstract class CommonTests<T> : InterpreterTest
    {
        protected const string FullInstructionNameFormat = "{0}.{1}";
        protected abstract string TypeName { get; }
        protected abstract IStack<T> Stack { get; }

        protected abstract T[] GetValues(int count);

        protected virtual T[] Get2Different()
        {
            return this.GetValues(2);
        }

        protected virtual void Test(Expression expression)
        {
            this.interpreter.Interpret(expression);
        }

        protected abstract void CheckOtherStacksAreEmpty();

        [TestMethod]
        public virtual void TestEqualsTrue()
        {
            var values = this.GetValues(1);
            var merged = new[] { values[0], values[0] };

            this.Stack.Push(merged);

            var isBooleanStack = interpreter.BooleanStack.Count == 2;

            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));

            if (isBooleanStack)
            {
                Assert.AreEqual(1, this.Stack.Count);
            }
            else
            {
                Assert.AreEqual(0, this.Stack.Count);
            }

            Assert.IsTrue(interpreter.BooleanStack.Top);
        }

        [TestMethod]
        public virtual void TestEqualsFalse()
        {
            var values = this.Get2Different();
            this.Stack.Push(values);
            var isBooleanStack = interpreter.BooleanStack.Count == 2;

            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".="));

            if (isBooleanStack)
            {
                Assert.AreEqual(1, this.Stack.Count);
            }
            else
            {
                Assert.AreEqual(0, this.Stack.Count);
            }

            Assert.IsFalse(interpreter.BooleanStack.Top);
        }

        [TestMethod]
        public virtual void TestEqualsWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("=", 1);
        }

        [TestMethod]
        public virtual void TestPop()
        {
            var values = this.GetValues(2);
            this.Stack.Push(values);

            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".POP"));

            this.CheckOtherStacksAreEmpty();
        }

        [TestMethod]
        public virtual void TestSwap()
        {
            var values = this.GetValues(3);
            this.Stack.Push(values);

            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SWAP"));

            Assert.AreEqual(values[0], this.Stack[0]);
            Assert.AreEqual(values[2], this.Stack[1]);
            Assert.AreEqual(values[1], this.Stack[2]);

            this.CheckOtherStacksAreEmpty();
        }

        [TestMethod]
        public virtual void TestSwapWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("SWAP", 1);
        }


        [TestMethod]
        public virtual void TestRotate()
        {
            var values = this.GetValues(4);
            this.Stack.Push(values);

            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".ROT"));

            Assert.AreEqual(values[0], this.Stack[0]);
            Assert.AreEqual(values[3], this.Stack[1]);
            Assert.AreEqual(values[1], this.Stack[2]);
            Assert.AreEqual(values[2], this.Stack[3]);

            this.CheckOtherStacksAreEmpty();
        }

        [TestMethod]
        public virtual void TestRotateWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("ROT", 2);
        }

        [TestMethod]
        public virtual void TestShove()
        {
            var values = this.GetValues(3);
            this.Stack.Push(values);

            interpreter.IntegerStack.Push(1);
            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".SHOVE"));

            Assert.AreEqual(values[0], this.Stack[0]);
            Assert.AreEqual(values[2], this.Stack[1]);
            Assert.AreEqual(values[1], this.Stack[2]);

            this.CheckOtherStacksAreEmpty();
        }

        [TestMethod]
        public virtual void TestShoveWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("SHOVE", 1);
        }

        [TestMethod]
        public virtual void TestShoveWithNegativeIndex()
        {
            this.TestWithNegativeIndex("SHOVE");
        }

        [TestMethod]
        public virtual void TestYank()
        {
            var values = this.GetValues(3);
            this.Stack.Push(values);

            interpreter.IntegerStack.Push(1);
            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANK"));

            Assert.AreEqual(values[0], this.Stack[0]);
            Assert.AreEqual(values[2], this.Stack[1]);
            Assert.AreEqual(values[1], this.Stack[2]);

            this.CheckOtherStacksAreEmpty();
        }

        [TestMethod]
        public virtual void TestYankWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("YANK", 1);
        }

        [TestMethod]
        public virtual void TestYankWithNegativeIndex()
        {
            this.TestWithNegativeIndex("YANK");
        }

        [TestMethod]
        public virtual void TestYankDuplicate()
        {
            var values = this.GetValues(3);
            this.Stack.Push(values);

            interpreter.IntegerStack.Push(1);
            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".YANKDUP"));

            Assert.AreEqual(values[0], this.Stack[0]);
            Assert.AreEqual(values[1], this.Stack[1]);
            Assert.AreEqual(values[2], this.Stack[2]);
            Assert.AreEqual(values[1], this.Stack[3]);

            this.CheckOtherStacksAreEmpty();
        }

        [TestMethod]
        public virtual void TestYankDuplicateWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("YANKDUP", 1);
        }

        [TestMethod]
        public virtual void TestYankDuplicateWithNegativeIndex()
        {
            this.TestWithNegativeIndex("YANKDUP");
        }

        [TestMethod]
        public virtual void TestStackdpeth()
        {
            var values = this.GetValues(3);
            this.Stack.Push(values);

            this.Test(ExpressionTable.GetStatelessExpression(this.TypeName + ".STACKDEPTH"));

            // if stack is integer stack
            if (this.Stack.Count != values.Length)
            {
                Assert.AreEqual(4, this.Stack.Count);
                this.CheckOtherStacksAreEmpty();
            }
            else
            {
                Assert.AreEqual(3, this.Stack.Count);
                Assert.AreEqual(values.Length, interpreter.IntegerStack.Top);
            }
        }

        protected void TestWithInsufficientArguments(string instructionName, int argCount = 0)
        {
            for (var i = 0; i < argCount + 1; i++)
            {
                var values = this.GetValues(i);
                this.Stack.Push(values);

                var fullInstructionname = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
                this.Test(ExpressionTable.GetStatelessExpression(fullInstructionname));

                for (var j = 0; j < i; j++)
                {
                    Assert.AreEqual(values[j], this.Stack[j]);
                }

                this.CheckOtherStacksAreEmpty();
                interpreter.Clear();
            }
        }

        protected void TestWithNegativeIndex(string instructionName)
        {
            var values = this.GetValues(1);
            this.Stack.Push(values);

            interpreter.IntegerStack.Push(-1);

            var fullInstructionname = string.Format(FullInstructionNameFormat, this.TypeName, instructionName);
            this.Test(ExpressionTable.GetStatelessExpression(fullInstructionname));

            Assert.AreEqual(values[0], this.Stack[0]);
        }
    }
}