Test case

[Andy333]

Hi,
Can anyone help with this scenario:

Using only NUnit Assert.AreEqual method, write tests for the BankAccount class that cover the following cases:
.The Deposit & Withdraw methods will not accept negative numbers.
.BankAccount cannot overstep its overdraft limit.
.The Deposit & Withdraw methods will deposit or withdraw the correct amount, respectively.
.The Withdraw & Deposit methods return the correct results.

public class BankAccount
    {
        public double Balance { get; private set; }
        public double OverdraftLimit { get; private set; }
        public BankAccount(double overdraftLimit)
        {
            this.OverdraftLimit = overdraftLimit > 0 ? overdraftLimit : 0;
        }

        public bool Deposit(double amount)
        {
            if(amount >=0)
            {
                this.Balance += amount;
                return true;
            }
            return false;
        }

        public bool Withdraw(double amount)
        {
            if(this.Balance - amount >= -this.OverdraftLimit && amount >= 0)
            {
                this.Balance -= amount;
                return true;
            }
            return false;
        }
    }

Each of the test case methods should be the Tester class & have the Test attribute.

using System;
using NUnit.Framework;

[TestFixture]
public class Tester
{  
    private double epsilon = 1e-6;

    [Test]
    public void BankAccountCannotHaveNegativeOverdraftLimit()
    {
        BankAccount account = new BankAccount(-20);
       
        Assert.AreEqual(0, account.OverdraftLimit, epsilon);
    }
}

TIA

 

[Phro0244]

Here's an example implementation of NUnit test methods that cover the scenarios you mentioned:

C#: [TestFixture] public class Tester {
private double epsilon = 1e-6;

[Test]
public void DepositShouldNotAcceptNegativeNumbers()
{
BankAccount account = new BankAccount(100);
bool result = account.Deposit(-50);
Assert.IsFalse(result);
Assert.AreEqual(0, account.Balance, epsilon);
}

[Test]
public void WithdrawShouldNotAcceptNegativeNumbers()
{
BankAccount account = new BankAccount(100);
bool result = account.Withdraw(-50);
Assert.IsFalse(result);
Assert.AreEqual(0, account.Balance, epsilon);
}

[Test]
public void BankAccountCannotOverstepOverdraftLimit()
{
BankAccount account = new BankAccount(100);
account.Deposit(50);
bool result = account.Withdraw(200);
Assert.IsFalse(result);
Assert.AreEqual(50, account.Balance, epsilon);
}

[Test]
public void DepositShouldDepositCorrectAmount()
{
BankAccount account = new BankAccount(100);
bool result = account.Deposit(50);
Assert.IsTrue(result);
Assert.AreEqual(50, account.Balance, epsilon);
}

[Test]
public void WithdrawShouldWithdrawCorrectAmount()
{
BankAccount account = new BankAccount(100);
account.Deposit(50);
bool result = account.Withdraw(25);
Assert.IsTrue(result);
Assert.AreEqual(25, account.Balance, epsilon);
}

[Test]
public void DepositShouldReturnTrueIfSuccessful()
{
BankAccount account = new BankAccount(100);
bool result = account.Deposit(50);
Assert.IsTrue(result);
}

[Test]
public void WithdrawShouldReturnTrueIfSuccessful()
{
BankAccount account = new BankAccount(100);
account.Deposit(50);
bool result = account.Withdraw(25);
Assert.IsTrue(result);
}

}

In the above code, each test method has a descriptive name that indicates the scenario being tested. Inside each test method, we create an instance of the BankAccount class, perform the necessary operations, and then use Assert.AreEqual and Assert.IsTrue/Assert.IsFalse to verify that the results match our expectations. We also use the epsilon variable to set a tolerance for comparing double values.