PG0008.Question1

[jack81722]

Introduction

請各位根據我提供的程式碼，
撰寫自己的測試程式碼。

測試如何寫通常不會有硬性要求，
不過通常可以看看公司內(如果已就業)的測試程式碼怎麼寫，
跟著寫即可。

測試最好的情況我們會要求覆蓋率達到90%以上，
簡單來說只要你有if，那麼你就要測試滿足與不滿足if的情況。

Answer

解答

// 測試有爆擊的狀態下，攻擊力有加倍
// 爆擊率可以破百，但不會有額外的傷害增加
[TestCase(1f, 1f)]
[TestCase(0.5f, 0.6f)]
[TestCase(0.5f, 1.3f)]
public void TestDamage_Critical(float rand, float critRate)
{
    var mockRand = new MockRandom(rand);
    var calculator = new DamageCalculator(mockRand);

    Assert.AreEqual(9, calculator.Damage(6, critRate));
}


// 測試沒有爆擊的狀態下，攻擊力不加倍
[TestCase(0f, 0f)]
[TestCase(0.4f, 0.3f)]
public void TestDamange_NotCritical(float rand, float critRate)
{
    var mockRand = new MockRandom(rand);
    var calculator = new DamageCalculator(mockRand);

    Assert.AreEqual(6, calculator.Damage(6, critRate));
}

// 測試在爆擊的狀態下，攻擊力加倍後會無條件捨去
[TestCase(10, 15)]
[TestCase(9, 13)]
public void TestDamage_CriticalDamange(int atk, int expectedAtk)
{
    var critRate = 0.6f;
    var mockRand = new MockRandom(0.5f);
    var calculator = new DamageCalculator(mockRand);

    Assert.AreEqual(expectedAtk, calculator.Damage(atk, critRate));
}

// 測試小於零的攻擊力得出來的結果必不為負數
[Test]
public void TestDamange_NegativeAtk()
{
    var critRate = 0.6f;
    var mockRand = new MockRandom(0.5f);
    var calculator = new DamageCalculator(mockRand);

    Assert.AreEqual(0, calculator.Damage(-1, critRate));
}

// 測試爆擊率低於零時，正確丟出錯誤
[TestCase(-0.00001f)]
public void TestDamage_ThrowArgError(float critRate)
{
    var mockRand = new MockRandom(0.5f);
    var calculator = new DamageCalculator(mockRand);

    Assert.Throws<ArgumentException>(() =>
    {
        calculator.Damage(1, critRate);
    });
}

public class MockRandom : IRandom
{
    public float _value;

    public MockRandom(float value) { _value = value; }    

    public float Next()
    {
        return _value;
    }
}

[OLDShaw1022]

老蕭OLDShaw（程式）

我的答案

namespace PG0008.Tests
{
    public class MockRandom : IRandom
    {
        float _rand;
        public MockRandom(float rand) 
        {
            _rand = rand;
        }
        public float Next()
        {
            return _rand;
        }
    }
    public class Question1Test
    {
        [Test]
        public void TestInvalidCritRate()
        {
            MockRandom random = new(0);
            DamageCalculator damageCalculator = new(random);
            int atk = 0;
            float critRate = -1;

            Assert.Throws<ArgumentException>(() => { damageCalculator.Damage(atk, critRate); });
        }

        [TestCase(15, 100, 100, 10)]
        [TestCase(10, 0, 0, 10)]
        public void TestCrit(int result, int rand, float critRate, int atk)
        {
            MockRandom random = new(rand);
            DamageCalculator damageCalculator = new(random);

            Assert.AreEqual(result, damageCalculator.Damage(atk, critRate));
        }

        [Test]
        public void TestNegativeAtk()
        {
            MockRandom random = new(0);
            DamageCalculator damageCalculator = new(random);
            int atk = -1;
            float critRate = 0;

            Assert.AreEqual(0, damageCalculator.Damage(atk, critRate));
        }
    }
}

測試截圖

[jack81722]

測試時可以考慮一些數值邊界的問題，
例如在機率當中你是[0, 1)還是(0, 1]兩種情況邏輯上是不同的，
或是float到int的轉型問題是否正確等等

[louise-bwsx]

小4 ( 程式 )

答案

public class PG0008Test
{
    [TestCase(0)]
    [TestCase(1)]
    [TestCase(null)]
    [TestCase(int.MaxValue)]
    public void TestDamage_Critical(int atk)
    {
        MoqRandom random = new MoqRandom(0);
        DamageCalculator dc = new DamageCalculator(random);
        int actual = dc.Damage(atk, 1);
        int expected = (int)(atk * 1.5f);
        Assert.AreEqual(expected, actual);
    }

    [TestCase(0)]
    [TestCase(1)]
    [TestCase(null)]
    [TestCase(int.MaxValue)]
    public void TestDamage_NoCritical(int atk)
    {
        MoqRandom random = new MoqRandom(1);
        DamageCalculator dc = new DamageCalculator(random);
        int actual = dc.Damage(atk, 0);
        float expected = atk;
        Assert.AreEqual((int)expected, actual);
    }

    [TestCase(0, 1)]
    [TestCase(int.MaxValue, float.MaxValue)]
    public void TestDamage_RandomNegative(int atk, float critRate)
    {
        MoqRandom random = new MoqRandom(-1);
        DamageCalculator dc = new DamageCalculator(random);
        Assert.AreEqual((int)(atk * 1.5f), dc.Damage(atk, critRate));
    }

    [TestCase(0)]
    [TestCase(1)]
    [TestCase(null)]
    [TestCase(int.MaxValue)]
    public void TestDamage_AttackNegative(float critRate)
    {
        MoqRandom random = new MoqRandom();
        DamageCalculator dc = new DamageCalculator(random);
        Assert.AreEqual(0, dc.Damage(-1, critRate));
    }

    [TestCase(0)]
    [TestCase(1)]
    [TestCase(null)]
    [TestCase(int.MaxValue)]
    [TestCase(int.MinValue)]
    public void TestDamage_CritRateNegative(int atk)
    {
        Assert.Throws<ArgumentException>(() =>
        {
            MoqRandom random = new MoqRandom();
            DamageCalculator dc = new DamageCalculator(random);
            int actual = dc.Damage(atk, -1);
        });
    }
}

public class MoqRandom : IRandom
{
    private bool test;
    private float value;

    public MoqRandom(float value)
    {
        test = true;
        this.value = value;
    }

    public MoqRandom()
    {
    }

    public float Next()
    {
        if (test)
        {
            return value;
        }
        Random random = new Random();
        return random.Next();
    }
}

反饋

我好像搞錯重點了 我以為要驗證有沒有算錯數值 所以直接Damage裡面的code直接貼到test裡面去 理所當然的測試全對
後來看了答案發現 寫這種測試的時候都不會在code中加if 就再重寫一遍

然後我發現一個問題 如果Damage的atk給int.MaxValue就算沒有爆擊還是會溢位耶

int max = int.MaxValue;
float fMax = max;
Debug.Log((int)fMax);

[jack81722]

你有想到MaxValue的case相當不錯，
這個數值是否這樣做可以跟(數值)企劃詢問確認需求，
不然這個問題可以無限上綱=> long? big integer?
也有clicker類型的遊戲採用自己的進位方式來避免這類問題，
溢位的問題可以參考stack overflow