root/lang/csharp/DominionEngine/DominionEngine.CardInfo.Test/Unit/WorthTest.cs @ 37714

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;

namespace DominionEngine.CardInfo.Test
{
    [TestFixture]
    public class WorthTest
    {
        #region Afford

        [TestCaseSource("IsAffordSource")]
        public void IsAfford(Worth cost, bool expected)
        {
            Worth money = Worth.Coin(3) + Worth.Create<Potion>(1);
            Assert.That(money.IsAfford(cost), Is.EqualTo(expected));
        }
        static object[][] IsAffordSource = new object[][]{
            new object[]{Worth.Coin(1), true},
            new object[]{Worth.Coin(2), true},
            new object[]{Worth.Coin(3), true},
            new object[]{Worth.Coin(4), false},
            new object[]{Worth.Create<Potion>(1), true},
            new object[]{Worth.Create<Potion>(2), false},
            new object[]{Worth.Coin(1) + Worth.Create<Potion>(1), true},
            new object[]{Worth.Coin(2) + Worth.Create<Potion>(1), true},
            new object[]{Worth.Coin(3) + Worth.Create<Potion>(1), true},
            new object[]{Worth.Coin(4) + Worth.Create<Potion>(1), false},
            new object[]{Worth.Coin(2) + Worth.Create<Potion>(2), false},
        };

        #endregion

        #region ToString

        [TestCaseSource("ToStringTestSource")]
        public void ToStringTest(Worth worth, string expected)
        {
            Assert.That(worth.ToString(), Is.EqualTo(expected));
        }
        public static object[][] ToStringTestSource = new object[][]{
            new object[]{Worth.Coin(1), "1C"},
            new object[]{Worth.Create<Potion>(1), "0C"},
            new object[]{Worth.Coin(1) + Worth.Create<Potion>(2), "1C"},
        };

        #endregion

        #region MoreThan

        [Test]
        public void MoreThan_Worth([Range(0, 10)]int baseCoin, [Range(0, 10)]int moreCoin)
        {
            Worth worth = Worth.Coin(baseCoin).MoreThan(Worth.Coin(moreCoin));

            Assert.That(worth.CoinValue, Is.EqualTo(baseCoin + moreCoin));
        }

        [Test]
        public void MoreThan_CardInfo([Range(0, 10)]int baseCoin, [Range(0, 10)]int moreCoin)
        {
            Worth worth = Worth.Coin(baseCoin).MoreThan(new MockCardInfo(Worth.Coin(moreCoin)));

            Assert.That(worth.CoinValue, Is.EqualTo(baseCoin + moreCoin));
        }

        [Test]
        public void MoreThan_Card([Range(0, 10)]int baseCoin, [Range(0, 10)]int moreCoin)
        {
            CardInfo cardInfo = new MockCardInfo(Worth.Coin(moreCoin));
            Worth worth = Worth.Coin(baseCoin).MoreThan(new Card(cardInfo, CardPosition.Supply));

            Assert.That(worth.CoinValue, Is.EqualTo(baseCoin + moreCoin));
        }

        #endregion

        #region 等価比較

        [Test]
        public void EqualsTest([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin);
            Worth worth2 = Worth.Coin(coin);

            Assert.That(worth1.Equals(worth2), Is.True);
        }

        [Test]
        public void EqualsTest_NotEqual([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin);
            Worth worth2 = Worth.Coin(coin+1);

            Assert.That(worth1.Equals(worth2), Is.False);
        }

        [Test]
        public void EqualsTest_NotEqual_NoWorth([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin);

            Assert.That(worth1.Equals(new object()), Is.False);
        }

        [Test]
        public void EqualsTest_WithOtherUnit([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin) + Worth.Create<Potion>(1);
            Worth worth2 = Worth.Create<Potion>(1) + Worth.Coin(coin);

            Assert.That(worth1, Is.EqualTo(worth2));
        }

        [Test]
        public void EqualsTest_WithOtherUnit_NotEqual([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin) + Worth.Create<Potion>(1);
            Worth worth2 = Worth.Coin(coin);

            Assert.That(worth1, Is.Not.EqualTo(worth2));
        }

        [Test]
        public void GetHashCodeTest([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin);
            Worth worth2 = Worth.Coin(coin);

            Assert.That(worth1.GetHashCode(), Is.EqualTo(worth2.GetHashCode()));
        }

        [Test]
        public void GetHashCodeTest_NotEqual([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin);
            Worth worth2 = Worth.Coin(coin+1);

            Assert.That(worth1.GetHashCode(), Is.Not.EqualTo(worth2.GetHashCode()));
        }

        [Test]
        public void GetHashCodeTest_WithOtherUnit([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin) + Worth.Create<Potion>(1);
            Worth worth2 = Worth.Create<Potion>(1) + Worth.Coin(coin);

            Assert.That(worth1.GetHashCode(), Is.EqualTo(worth2.GetHashCode()));
        }

        [Test]
        public void GetHashCodeTest_WithOtherUnit_NotEqual([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin) + Worth.Create<Potion>(1);
            Worth worth2 = Worth.Coin(coin);

            Assert.That(worth1.GetHashCode(), Is.Not.EqualTo(worth2.GetHashCode()));
        }

        [Test]
        public void EqualsOperatorTest([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin);
            Worth worth2 = Worth.Coin(coin);

            Assert.That((worth1 == worth2), Is.True);
        }

        [Test]
        public void EqualsOperatorTest_Same([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin);
            Worth worth2 = worth1;

            Assert.That((worth1 == worth2), Is.True);
        }

        [Test]
        public void EqualsOperatorTest_NotEqual([Range(0, 10)]int coin)
        {
            Worth worth1 = Worth.Coin(coin);
            Worth worth2 = Worth.Coin(coin + 1);

            Assert.That((worth1 != worth2), Is.True);
        }

        #endregion

        #region 個別の価値

        [Test]
        public void CoinValue()
        {
            Worth cost = Worth.Coin(3) + Worth.Create<Potion>(2);
            Assert.That(cost.CoinValue, Is.EqualTo(3));
        }

        [Test]
        public void PotionValue()
        {
            Worth cost = Worth.Coin(3) + Worth.Create<Potion>(2);
            Assert.That(cost.Value<Potion>(), Is.EqualTo(2));
        }

        #endregion

        #region 算術演算子

        [Test]
        public void Add()
        {
            Worth cost = Worth.Coin(1) + Worth.Coin(1) + Worth.Create<Potion>(1);
            Assert.That(cost.CoinValue, Is.EqualTo(2));
            Assert.That(cost.Value<Potion>(), Is.EqualTo(1));
        }

        [Test]
        public void Sub()
        {
            Worth cost1 = Worth.Coin(3) + Worth.Create<Potion>(5);
            Worth cost2 = Worth.Coin(1) + Worth.Create<Potion>(4);

            Worth cost = cost1 - cost2;

            Assert.That(cost.CoinValue, Is.EqualTo(2));
            Assert.That(cost.Value<Potion>(), Is.EqualTo(1));
        }

        [Test]
        public void Sub_NoUnit()
        {
            Worth cost1 = Worth.Coin(3);
            Worth cost2 = Worth.Coin(1) + Worth.Create<Potion>(4);

            Worth cost = cost1 - cost2;

            Assert.That(cost.CoinValue, Is.EqualTo(2));
            Assert.That(cost.Value<Potion>(), Is.EqualTo(-4));
        }

        #endregion

        [Test]
        public void WorthExtension([Range(0, 10)] int value)
        {
            Worth worth = value.Coin();
            Assert.That(worth.CoinValue, Is.EqualTo(value));
        }

        public class Potion : Worth.Unit { }
    }
}