Exercise 5 Test Cases

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
using Plato.Core;
using Plato.Language;

namespace Tests
{
    [TestFixture]
    public class Exercise5
    {
        Brain brain;
        IEntity noun;
        IEntity speaker;
        IEntity first_name;

        [SetUp]
        public void SetUp()
        {
            brain = new Brain();

            brain.CreateEntity("noun");
            brain.CreateEntity("speaker");
            brain.CreateEntity("first_name");

            noun = brain.Get("noun");
            Assert.IsNotNull(noun);

            speaker = brain.Get("speaker");
            Assert.IsNotNull(speaker);

            first_name = brain.Get("first_name");
            Assert.IsNotNull(first_name);
        }

        /// <summary>
        /// Ensure LiteralToken's ToString() method works properly.
        /// </summary>
        [Test]
        public void LiteralToken_ToString()
        {
            LiteralToken token = new LiteralToken("my");
            Assert.AreEqual("my", token.ToString());
        }

        /// <summary>
        /// Ensure VariableToken's ToString() method works properly.
        /// </summary>
        [Test]
        public void VariableToken_ToString()
        {
            VariableToken token = new VariableToken(1);
            Assert.AreEqual("$1", token.ToString());
        }

        /// <summary>
        /// Ensure EntityToken's ToString() method works properly.
        /// </summary>
        [Test]
        public void EntityToken_ToString()
        {
            EntityToken token = new EntityToken(noun);
            Assert.AreEqual("noun", token.ToString());
        }

        /// <summary>
        /// Ensure EntityTypeToken's ToString() method works properly.
        /// </summary>
        [Test]
        public void EntityTypeToken_ToString()
        {
            EntityTypeToken token = new EntityTypeToken(noun);
            Assert.AreEqual("noun", token.ToString());
        }

        /// <summary>
        /// Ensure PropertyToken's ToString() method works properly.
        /// </summary>
        [Test]
        public void PropertyToken_ToString()
        {
            IList<IPropertyPathToken> path = new List<IPropertyPathToken>();
            path.Add(new EntityToken(speaker));
            path.Add(new VariableToken(1));
            PropertyToken property = new PropertyToken(path);
            Assert.AreEqual("speaker.$1", property.ToString());
        }

        /// <summary>
        /// Ensure EntityTypeToken's ToString() method works properly.
        /// </summary>
        /// <remarks>
        /// Containing a fragment.
        /// </remarks>
        [Test]
        public void PropertyToken_Fragment_ToString()
        {
            LiteralToken token;
            IList<IToken> tokens = new List<IToken>();

            token = new LiteralToken("born");
            tokens.Add(token);
            token = new LiteralToken("in");
            tokens.Add(token);
            token = new LiteralToken("year");
            tokens.Add(token);

            Fragment fragment = new Fragment(tokens);

            IList<IPropertyPathToken> path = new List<IPropertyPathToken>();
            path.Add(new EntityToken(speaker));
            path.Add(new FragmentToken(fragment));
            PropertyToken property = new PropertyToken(path);
            Assert.AreEqual("speaker.((born in year))", property.ToString());
        }

        /// <summary>
        /// Ensure Fragment's ToString() method works properly.
        /// </summary>
        /// <remarks>
        /// Test EntityTypeToken
        /// </remarks>
        [Test]
        public void Fragment_ToString_EntityTypeToken()
        {
            EntityTypeToken token = new EntityTypeToken(noun);
            IList<IToken> tokens = new List<IToken>();

            tokens.Add(token);
            Fragment fragment = new Fragment(tokens);

            Assert.AreEqual("{noun}", fragment.ToString());
        }

        /// <summary>
        /// Ensure Fragment's ToString() method works properly.
        /// </summary>
        /// <remarks>
        /// Test EntityToken
        /// </remarks>
        [Test]
        public void Fragment_ToString_EntityToken()
        {
            EntityToken token = new EntityToken(noun);

            IList<IToken> tokens = new List<IToken>();
            tokens.Add(token);

            Fragment fragment = new Fragment(tokens);

            Assert.AreEqual("[noun]", fragment.ToString());
        }

        /// <summary>
        /// Ensure Fragment's ToString() method works properly.
        /// </summary>
        /// <remarks>
        /// Test PropertyToken
        /// </remarks>
        [Test]
        public void Fragment_ToString_PropertyToken()
        {
            IList<IPropertyPathToken> path = new List<IPropertyPathToken>();
            path.Add(new EntityToken(speaker));
            path.Add(new EntityToken(first_name));
            PropertyToken token = new PropertyToken(path);

            IList<IToken> tokens = new List<IToken>();
            tokens.Add(token);

            Fragment fragment = new Fragment(tokens);

            Assert.AreEqual("[speaker.first_name]", fragment.ToString());
        }

        /// <summary>
        /// Ensure Fragment's ToString() method works properly.
        /// </summary>
        /// <remarks>
        /// Test VariableToken; used in transformation output fragments
        /// that are nested in properties.
        /// ex. {noun} was {noun} {verb} {participle} -> $2.(($3 $4 $1))
        /// </remarks>
        [Test]
        public void Fragment_ToString_VariableToken()
        {
            VariableToken token;
            IList<IToken> tokens = new List<IToken>();

            token = new VariableToken(3);
            tokens.Add(token);
            token = new VariableToken(4);
            tokens.Add(token);
            token = new VariableToken(1);
            tokens.Add(token);

            Fragment fragment = new Fragment(tokens);

            Assert.AreEqual("$3 $4 $1", fragment.ToString());
        }

        /// <summary>
        /// my {noun} -> speaker.$1
        /// </summary>
        [Test]
        public void Transformation1_ToString()
        {
            IList<IInputToken> inputTokens = new List<IInputToken>();
            inputTokens.Add(new LiteralToken("my"));
            inputTokens.Add(new EntityTypeToken(noun));
            TransInput input = new TransInput(inputTokens);

            IList<IPropertyPathToken> path = new List<IPropertyPathToken>();
            path.Add(new EntityToken(speaker));
            path.Add(new VariableToken(1));
            PropertyToken property = new PropertyToken(path);
            TransOutput_Value output = new TransOutput_Value(property);

            Transformation t = new Transformation(input, output);

            Assert.AreEqual(t.ToString(), "my {noun} -> speaker.$1");
        }
    }
}