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

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

namespace HeuristicLab.Tests.Interpreter.Expressions
{
    [TestClass]
    public class FloatExpressionTests : CommonTests<double>
    {
        private const double delta = 0.00001;
        protected override string TypeName { get { return "FLOAT"; } }
        protected override IStack<double> Stack { get { return interpreter.FloatStack; } }

        [TestMethod]
        public void TestAdd()
        {
            interpreter.FloatStack.Push(5.3, 5.3);
            interpreter.Interpret(new FloatAddExpression());

            Assert.AreEqual(10.6, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestAddWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("+", 1);
        }

        [TestMethod]
        public void TestSubtract()
        {
            interpreter.FloatStack.Push(10.2, 5.3);
            interpreter.Interpret(new FloatSubtractExpression());

            Assert.AreEqual(4.9, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestSubractWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("-", 1);
        }

        [TestMethod]
        public void TestMultiply()
        {
            interpreter.FloatStack.Push(9.9, 3.3);
            interpreter.Interpret(new FloatMultiplyExpression());

            Assert.AreEqual(32.67, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestMultiplyWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("*", 1);
        }

        [TestMethod]
        public void TestDivide()
        {
            interpreter.FloatStack.Push(9.9, 3.3);
            interpreter.Interpret(new FloatDivideExpression());

            Assert.AreEqual(3.0, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestDivideWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("/", 1);
        }

        [TestMethod]
        public void TestModulo()
        {
            interpreter.FloatStack.Push(11.6, 5.3);
            interpreter.Interpret(new FloatModuloExpression());

            Assert.AreEqual(1, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestModuloWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("%", 1);
        }

        [TestMethod]
        public void TestMin()
        {
            interpreter.FloatStack.Push(10.2, 5.3);
            interpreter.Interpret(new FloatMinExpression());

            Assert.AreEqual(5.3, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestMinWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("MIN", 1);
        }

        [TestMethod]
        public void TestMax()
        {
            interpreter.FloatStack.Push(10.3, 5.3);
            interpreter.Interpret(new FloatMaxExpression());

            Assert.AreEqual(10.3, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestMaxWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("MAX", 1);
        }

        [TestMethod]
        public void TestSmallerThan()
        {
            interpreter.FloatStack.Push(10.2, 5.3);
            interpreter.Interpret(new FloatSmallerThanExpression());

            Assert.AreEqual(false, interpreter.BooleanStack.Top);

            this.TestStackCounts(booleanStack: 1);
        }

        [TestMethod]
        public void TestSmallerThanWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("<", 1);
        }

        [TestMethod]
        public void TestGreaterThan()
        {
            interpreter.FloatStack.Push(10.2, 5.3);
            interpreter.Interpret(new FloatGreaterThanExpression());

            Assert.AreEqual(true, interpreter.BooleanStack.Top);

            this.TestStackCounts(booleanStack: 1);
        }

        [TestMethod]
        public void TestGreaterThanWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments(">", 1);
        }

        [TestMethod]
        public void TestFromBooleanTrue()
        {
            interpreter.BooleanStack.Push(true);
            interpreter.Interpret(new FloatFromBooleanExpression());

            Assert.AreEqual(1d, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestFromBooleanFalse()
        {
            interpreter.BooleanStack.Push(false);
            interpreter.Interpret(new FloatFromBooleanExpression());

            Assert.AreEqual(0d, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestFromBooleanWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("FROMBOOLEAN");
        }

        [TestMethod]
        public void TestFromInteger()
        {
            interpreter.IntegerStack.Push(5);
            interpreter.Interpret(new FloatFromIntegerExpression());

            Assert.AreEqual(5d, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestFromIntegerWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("FROMINTEGER");
        }

        [TestMethod]
        public void TestSine()
        {
            interpreter.FloatStack.Push(Math.PI / 2);
            interpreter.Interpret(new FloatSineExpression());

            Assert.AreEqual(1, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestSineWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("SIN");
        }

        [TestMethod]
        public void TestCosine()
        {
            interpreter.FloatStack.Push(Math.PI);
            interpreter.Interpret(new FloatCosineExpression());

            Assert.AreEqual(-1, interpreter.FloatStack.Top, delta);

            this.TestStackCounts(floatStack: 1);
        }

        [TestMethod]
        public void TestCosineWithInsufficientArguments()
        {
            this.TestWithInsufficientArguments("COS");
        }

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

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

            return values;
        }

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