using System;

using NUnit.Framework;

using System.Linq;

using System.Reflection;

public class Program

{

    public static void Main()

    {

        var testClass = new CarResidualValueCalculatorTests();

    var methods = typeof(CarResidualValueCalculatorTests)

        .GetMethods(BindingFlags.Public | BindingFlags.Instance)

        .Where(m => m.GetCustomAttribute<TestAttribute>() != null);

​

    foreach (var method in methods)

    {

        try

        {

            // Ensure Setup() is called before each test to initialize _splitter

            testClass.Setup(); 

            method.Invoke(testClass, null);

            Console.WriteLine($"{method.Name}: Passed");

        }

        catch (Exception ex)

        {

            Console.WriteLine($"{method.Name}: Failed - {ex.InnerException?.Message}");

        }

    }

    }

}

​

// CarResidualValueCalculator.cs

​

public interface IResidualValueCalculator

{

    decimal CalculateResidualValue(decimal initialPrice, int age, decimal depreciationRate);

}

​

public class CarResidualValueCalculator : IResidualValueCalculator

{

    public decimal CalculateResidualValue(decimal initialPrice, int age, decimal depreciationRate)

    {

        if (initialPrice < 0 || age < 0 || depreciationRate < 0 || depreciationRate > 1)

        {

            throw new ArgumentException("Invalid input parameters.");

        }

​

        return initialPrice * (decimal)Math.Pow(1 - (double)depreciationRate, age);

    }

}

​

// CarResidualValueCalculatorTests.cs

​

​

​

public class CarResidualValueCalculatorTests

{

    private IResidualValueCalculator _calculator;

​

    [SetUp]

    public void Setup()

    {

        _calculator = new CarResidualValueCalculator();

    }

​

    [Test]

    public void CalculateResidualValue_ValidInput_ReturnsCorrectValue()

    {

        decimal initialPrice = 30000;

        int age = 3;

        decimal depreciationRate = 0.10m;

        decimal expectedResidualValue = 21870;

​

        decimal actualResidualValue = _calculator.CalculateResidualValue(initialPrice, age, depreciationRate);

​

        Assert.That(actualResidualValue, Is.EqualTo(expectedResidualValue).Within(0.01)); // Allow for minor floating-point differences

    }

​

    [Test]

    public void CalculateResidualValue_ZeroAge_ReturnsInitialPrice()

    {

        decimal initialPrice = 25000;

        int age = 0;

        decimal depreciationRate = 0.15m;

        decimal expectedResidualValue = 25000;

​

        decimal actualResidualValue = _calculator.CalculateResidualValue(initialPrice, age, depreciationRate);

​

        Assert.That(actualResidualValue, Is.EqualTo(expectedResidualValue).Within(0.01));

    }

​

    [Test]

    public void CalculateResidualValue_ZeroDepreciationRate_ReturnsInitialPrice()

    {

        decimal initialPrice = 40000;

        int age = 5;

        decimal depreciationRate = 0m;

        decimal expectedResidualValue = 40000;

​

        decimal actualResidualValue = _calculator.CalculateResidualValue(initialPrice, age, depreciationRate);

​

        Assert.That(actualResidualValue, Is.EqualTo(expectedResidualValue).Within(0.01));

    }

​

    [Test]

    public void CalculateResidualValue_NegativeInitialPrice_ThrowsArgumentException()

    {

        decimal initialPrice = -1000;

        int age = 2;

        decimal depreciationRate = 0.05m;

​

        Assert.Throws<ArgumentException>(() => _calculator.CalculateResidualValue(initialPrice, age, depreciationRate));

    }

​

    [Test]

    public void CalculateResidualValue_NegativeAge_ThrowsArgumentException()

    {

        decimal initialPrice = 35000;

        int age = -1;

        decimal depreciationRate = 0.08m;

​

        Assert.Throws<ArgumentException>(() => _calculator.CalculateResidualValue(initialPrice, age, depreciationRate));

    }

​

    [Test]

    public void CalculateResidualValue_NegativeDepreciationRate_ThrowsArgumentException()

    {

        decimal initialPrice = 28000;

        int age = 4;

        decimal depreciationRate = -0.10m;

​

        Assert.Throws<ArgumentException>(() => _calculator.CalculateResidualValue(initialPrice, age, depreciationRate));

    }

​

    [Test]

    public void CalculateResidualValue_DepreciationRateGreaterThanOne_ThrowsArgumentException()

    {

        decimal initialPrice = 32000;

        int age = 1;

        decimal depreciationRate = 1.2m;

​

        Assert.Throws<ArgumentException>(() => _calculator.CalculateResidualValue(initialPrice, age, depreciationRate));

    }

}