【软件工程】复利计算程序单元测试

这次更新我将Money类中各种计算模式的算法封装到了Arithmetic算法类中，以便代码复用及代码测试。但是由于单元测试无法测试private修饰的方法，所以我将Arithmetic中的方法访问修饰符设为public，本次测试采用的工具是JUnit4，需要导入的包有org.junit.*以及org.hamcrest.CoreMatchers.*。

以下为修改后的源代码

主类Money

import java.util.Scanner;

public class Money {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入计算方式：1.单利计算 2.复利计算 3.本金计算 4.股票期限计算 5.利率计算 6.资产总值计算");
        // 选择计算方式
        int choose = scanner.nextInt();

        switch (choose) {
        case 1:
            danLiJiSuan(scanner); // 1.单利计算模式
            break;
        case 2:
            fuLiJiSuan(scanner); // 2.复利计算模式
            break;
        case 3:
            benJinJiSuan(scanner); // 3.本金计算模式
            break;
        case 4:
            guPiaoQiXian(scanner); // 4.股票计算模式
            break;
        case 5:
            liLvJiSuan(scanner); // 5.利率计算模式
            break;
        case 6:
            ziChanZongZhi(scanner); // 6.资产计算模式
            break;
        }
        scanner.close();

    }

    // 6.资产总值计算模式
    public static void ziChanZongZhi(Scanner scanner) {
        double P;
        double i;
        double N;
        double F;
        System.out.println("请输入本金：");
        P = scanner.nextDouble();
        System.out.println("请输入每年的投资金额：");
        double T = scanner.nextDouble();
        System.out.println("请输入投资年限：");
        N = scanner.nextInt();
        System.out.println("请输入利率：");
        i = scanner.nextDouble();
        // 调用计算方法
        F = Arithmetic.wayOfZiChanZongzhi(P, i, N, T);
        System.out.println("资产总值是：" + F);
    }

    // 5.利率计算模式
    public static void liLvJiSuan(Scanner scanner) {
        double P;
        double i;
        double N;
        double F;
        System.out.println("输入本金：");
        P = scanner.nextDouble();
        System.out.println("输入期限：");
        N = scanner.nextDouble();
        System.out.println("输入本息总值：");
        F = scanner.nextDouble();
        // 调用计算方法
        i = Arithmetic.wayOfLiLvJiSuan(P, N, F);
        System.out.println("利率为：" + i);
    }

    // 4.股票期限计算模式
    public static void guPiaoQiXian(Scanner scanner) {
        double P;
        double i;
        double N;
        double F;
        System.out.println("输入本金：");
        P = scanner.nextDouble();
        System.out.println("输入利率：");
        i = scanner.nextDouble();
        System.out.println("输入本息总值：");
        F = scanner.nextDouble();
        // 调用计算方法
        N = Arithmetic.wayOfGuPiaoQiXian(F, P, i);
        System.out.println("期限为：" + N);
    }

    // 3.本金计算模式
    public static void benJinJiSuan(Scanner scanner) {
        double P;
        double i;
        double N;
        double F;
        System.out.println("输入本息总值：");
        F = scanner.nextDouble();
        System.out.println("输入利率：");
        i = scanner.nextDouble();
        System.out.println("输入期限：");
        N = scanner.nextDouble();
        // 调用计算方法
        P = Arithmetic.wayOfBenJinJiSuan(i, N, F);
        System.out.println("应投入本金：" + P);
    }

    // 2.复利计算模式
    public static void fuLiJiSuan(Scanner scanner) {
        double P;
        double i;
        double N;
        double F;
        System.out.println("输入本金：");
        P = scanner.nextDouble();
        System.out.println("输入利率：");
        i = scanner.nextDouble();
        System.out.println("输入期限：");
        N = scanner.nextDouble();
        // 调用计算方法
        F = Arithmetic.wayOfFuLiJiSuan(P, i, N);
        System.out.println("本息总值为：" + F);
    }

    // 1.单利计算模式
    public static void danLiJiSuan(Scanner scanner) {
        double P;
        double i;
        double N;
        double F;
        System.out.println("输入本金：");
        P = scanner.nextDouble();
        System.out.println("输入利率：");
        i = scanner.nextDouble();
        System.out.println("输入期限：");
        N = scanner.nextDouble();
        F = Arithmetic.wayOfDanLiJiSuan(P, i, N);
        System.out.println("本息总值为：" + Math.round(F * 100) / 100.0);
    }

算法类Arithmetic

    
/** 封装复利计算程序的算法*/
public class Arithmetic {

    //资产总值计算模式的算法
    public static double wayOfZiChanZongzhi(double P, double i, double N, double T) {
        double F;
        for (int j = 0; j < N; j++) {
            P = P * (1 + i);
            P = P + T;
        }
        F = Math.round((P - T) * 100) / 100.0;
        return F;
    }
    
    //利率计算模式的算法
    public static double wayOfLiLvJiSuan(double P, double N, double F) {
        double i;
        i = F / (P * N);
        i = Math.round(i * 100) / 100.0;
        return i;
    }
    
    //股票期限计算模式模式的算法
    public static double wayOfGuPiaoQiXian(double F, double P, double i) {
        double N;
        N = (F - P) / (i * P);
        N = Math.round(N * 100) / 100.0;
        return N;
    }
    
    //本金计算模式的算法
    public static double wayOfBenJinJiSuan(double i, double N, double F) {
        double P;
        P = F / (1 + i * N);
        P = Math.round(P * 100) / 100.0;
        return P;
    }
    
    //复利计算模式的算法
    public static double wayOfFuLiJiSuan(double P, double i, double N) {
        double F;
        F = P * Math.pow((1 + i), N);
        F = Math.round(F * 100) / 100.0;
        return F;
    }
    
    //单利计算模式的算法
    public static double wayOfDanLiJiSuan(double P,double i,double N){
        double F;
        F = P + P * i * N;
        F = Math.round(F*100)/100.0;
        return F;
    }

}

测试类MoneyTest

import static org.junit.Assert.*;
import static org.hamcrest.CoreMatchers.*;
import org.junit.Before;
import org.junit.Test;

public class MoneyTest {
    @Before
    public void setUp() throws Exception {
    }

    @Test
    public void testWayOfZiChanZongzhi() { // 测试资产总值算法
        double f = Arithmetic.wayOfZiChanZongzhi(25000, 0.03, 4, 1350);
        assertThat(f, is(32435.62));
    }

    @Test
    public void testWayOfLiLvJiSuan() { // 测试利率计算算法
        double f = Arithmetic.wayOfLiLvJiSuan(10000, 3, 13640);
        assertThat(f, is(0.45));
    }

    @Test
    public void testWayOfGuPiaoQiXian() { // 测试股票期限算法
        double f = Arithmetic.wayOfGuPiaoQiXian(30000, 23000, 0.03);
        assertThat(f, is(10.14));
    }

    @Test
    public void testWayOfBenJinJiSuan() { // 测试本金计算算法
        double f = Arithmetic.wayOfBenJinJiSuan(0.06, 4, 25000);
        assertThat(f, is(20161.29));
    }

    @Test
    public void testWayOfFuLiJiSuan() { // 测试复利计算算法
        double f = Arithmetic.wayOfFuLiJiSuan(30000, 0.05, 3);
        assertThat(f, is(34728.75));
    }

    @Test
    public void testWayOfDanLiJiSuan() { // 测试单利计算算法
        double f = Arithmetic.wayOfDanLiJiSuan(10000, 0.03, 1);
        assertThat(f, is(10300.0));
    }

}

测试采用的是org.junit.Assert中的assertThat()方法，该方法有两个参数，第一个是测试的方法计算出来的结果（即待测数据），第二个是预期结果（即逻辑上的正确结果），该方法将这两个参数进行比较，如果相同则为true，即该方法测试通过，如果不同则为false，即该方法测试失败。

以下为测试结果截图

六个方法测试全部通过。

在测试类中，方法的前面用@Test标注的表明这是一个测试方法。

用@Ignore标注的表明这是一个尚未完成的方法，不参与本次测试，这样测试结果就会提示该方法被忽略，而不是失败。

用@Before标注的表明这是每个测试执行之前都必须执行的代码，可以用来对共享数据进行清零，避免上一次的测试数据影响下一次的测试结果。