结对编程第二次作业

四则运算——单元测试

一、小组成员及分工

• 杨爱清

1.学号:201421123099
2.博客链接（本博客）

• 杨立鑫

1.学号:201421123100
2.博客链接

• 分工

1.在提取计算模块上，杨爱清同学扮演领航员的角色，杨立鑫同学扮演驾驶员。
杨爱清同学提出了提取出来的类应该包含以下几个函数：

• add() （加）
• sub() （减）
• mul() （乘）
• div() （除）
• compare() （分数大小比较）
• GCD() （计算最大公约数）
• CreatFrac() （创建随即分数）
  杨立鑫同学根据根据同伴所说，在原程序中提取出了计算模块，并单独创建了一个类Fraction。（下方有Fraction代码）

2.在单元测试上，杨立鑫同学扮演领航员的角色，杨爱清同学扮演驾驶员。
杨立鑫同学提出，通过单元测试代码，要测试加法是否能正确工作，加减乘除功能，测试计算类对于各种参数的支持。针对提取出的模块杨爱清同学使用junit选择并构建了FractionTest类.

二、实验步骤

（1）需求分析：

1、通过单元测试代码，测试加法是否能正确工作；

2、通过单元测试代码，测试加减乘除功能。

3、通过单元测试代码，测试计算类对于各种参数的支持：

• 输入是有错误的，例如 “1 ++ 2”，

• 在数值范围是 -1000 .. 1000 的时候，传进去 “10000 + 32768”,

• 或者是 “ 248 / 0” 怎么办?

• 怎么告诉函数的调用者 “你错了”? 把返回的字符串定义为 “-1” 来表示？

• 那么如果真的计算结果是 “-1” 又怎么处理呢?

4、通过增量修改的方式，改进程序， 完成对各种错误情况的处理。

（2）单元测试：

通过产生随机数方法，反复测试所有单元；

单元测试代码：

package test;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class FractionTest {
	
	Fraction fraction=new Fraction();
	Fraction f1 = fraction.CreatFrac();
	Fraction f2 = fraction.CreatFrac();
	@Before
	public void setUp() throws Exception {
	}

	@Test
	public void testFraction() {
		
	}

	@Test
	public void testAdd() {
		fraction.add(f1, f2);
	}

	@Test
	public void testSub() {
		fraction.sub(f1, f2);
	}

	@Test
	public void testMul() {
		fraction.mul(f1, f2);
	}

	@Test
	public void testDiv() {
		fraction.div(f1, f2);
	}

	@Test
	public void testCompare() {
		fraction.compare(f1, f2);
	}

	@Test
	public void testCreatFrac() {
	
	}

}

测试结果截图：

代码覆盖率

三、总结

前面不知道怎么用git，感觉好复杂，差点就想不用这个工具了，后面还是觉得要克服困难，通过请教老师，才学会了如何使用git，还好没有放弃。这是第二次团队合作了，比第一次更有默契，两个人相互帮助，相互鼓励，达到了双赢，两个人都收获了知识，通过单元测试，明白了代码模块化的好处，不仅简洁明了，也方便后面的完善和改进，以后写代码要好好注意这个。

四、在隔了一周之后再看之前的代码，是否更能体会到下面这些东西

(1) 良好的设计

设计很重要，良好的设计方便查看，也方便改进完善,以前的代码斗没有怎么注意这点，后面再回去看很难一下子看懂，总要花上一点时间。

(2) 编码规范

编码规范没什么问题，就是代码的模块模块化没有做好。

(3) 必要的注释

在编写代码的过程之中我们都会注意加上注释，便于自己和助教查看代码。

五、PSP

PSP2.1	Personal Software Process Stages	Time (%) Senior Student(/hour)	Time (%)(/hour)
· Planning	计划	2	1
· Estimate	估计这个任务需要多少时间	4	5
· Analysis	需求分析 (包括学习新技术)	2	3
· Coding Standard	代码规范	1	0.5
· Design	具体设计	1.5	2
· Coding	具体编码	3	4
· Test	测试（自我测试，修改代码，提交修改）	2	1.5
Reporting	报告	1	2

六、附录

1.码云地址

2.小组成员探讨照片

3.Fraction代码

package test;

public class Fraction {

    private int fenzi;
    private int fenmu;

    public Fraction() {
        super();
    }

    public Fraction(int fenzi, int fenmu) {
        super();
        this.fenzi = fenzi;
        this.fenmu = fenmu;
        this.simplify(fenzi, fenmu); //在构造函数中直接化简分数（感觉此方法欠妥）
    }

    public static Fraction add(Fraction f1, Fraction f2) {

        int fz1 = f1.getFenzi();
        int fz2 = f2.getFenzi();
        int fm1 = f1.getFenmu();
        int fm2 = f2.getFenmu();
        Fraction f = new Fraction(fz1 * fm2 + fm1 * fz2, fm1 * fm2);
        return f;

    }//加法运算

    public static Fraction sub(Fraction f1, Fraction f2) {
        int fz1 = f1.getFenzi();
        int fz2 = f2.getFenzi();
        int fm1 = f1.getFenmu();
        int fm2 = f2.getFenmu();
        Fraction f = new Fraction(fz1 * fm2 - fm1 * fz2, fm1 * fm2);
        return f;
    }//减法运算

    public static Fraction mul(Fraction f1, Fraction f2) {
        int fz1 = f1.getFenzi();
        int fz2 = f2.getFenzi();
        int fm1 = f1.getFenmu();
        int fm2 = f2.getFenmu();
        Fraction f = new Fraction(fz1 * fz2, fm1 * fm2);
        return f;
    }//乘法运算

    public static Fraction div(Fraction f1, Fraction f2) {
        int fz1 = f1.getFenzi();
        int fz2 = f2.getFenzi();
        int fm1 = f1.getFenmu();
        int fm2 = f2.getFenmu();
        Fraction f = new Fraction(fz1 * fm2, fm1 * fz2);
        return f;
    }//除法运算

    public static boolean compare(Fraction f1, Fraction f2) {
        int fz1 = f1.getFenzi();
        int fz2 = f2.getFenzi();
        int fm1 = f1.getFenmu();
        int fm2 = f2.getFenmu();
        if (fz1 * fm2 >= fz2 * fm1) {
            return true;
        } else {
            return false;
        }
    }//比较两分数的大小

    public static int GCD(int m, int n) {
        while (true) {
            if ((m = m % n) == 0) {
                return n;
            }
            if ((n = n % m) == 0) {
                return m;
            }
        }
    }//计算最大公约数

    public void simplify(int fenzi, int fenmu) {
        int GCD = GCD(fenzi, fenmu);
        this.fenzi = fenzi / GCD;
        this.fenmu = fenmu / GCD;
    }//化简分数

    @Override
    public String toString() {
        if (fenzi == 0) {
            return 0 + "";
        } else if (fenzi % fenmu == 0) {
            return fenzi / fenmu + "";
        } else {
            return fenzi + "/" + fenmu;
        }
    }//改写toString，输出为分数形式

    public int getFenzi() {
        return fenzi;
    }

    public void setFenzi(int fenzi) {
        this.fenzi = fenzi;
    }

    public int getFenmu() {
        return fenmu;
    }

    public void setFenmu(int fenmu) {
        this.fenmu = fenmu;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + fenmu;
        result = prime * result + fenzi;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        Fraction other = (Fraction) obj;
        if (fenmu != other.fenmu) {
            return false;
        }
        if (fenzi != other.fenzi) {
            return false;
        }
        return true;
    }

    public static Fraction CreatFrac() {
        int fz, fm;
        fz = (int) (0 + Math.random() * (100 - 0 + 1));//分子取0--100的随机数
        fm = (int) (1 + Math.random() * (10 - 1 + 1));//分母取1--100的随机数
        Fraction frac = new Fraction(fz, fm);
        return frac;
    }//创建随机分数

}