java office execl框架 java框架怎么使用

一、介绍

1）Junit是专门测试java代码的框架
2）Junit的3和4的区别，建议直接用4就可以；4可以直接用注解，不需要继承TestCase；
3）为什么要用Junit？
我自己想到的2点：
1：如果你写测试案例，可能需要在各种地方写，不统一所以出现了Maven中的test包；
2：直接执行看结果；不需要再写main函数才进行调用，然后可能还要写system.out.println()才能知道自己写的方法对不对；

二、使用

在各种百度、资源下，学会使用了，表示一个人学习探索这些框架怎么用是真的痛苦，可能一个小小的问题都会导致你一直停滞下来，无法前进；
说说我在IDEA中的使用吧：
1）先安装junit插件；
File–>Plugins–>Browse Repositories –》JUnitGenerator V2.0
安装他，重启后，就可以用了；
2）在写完的类上，右键-》Go to -> Test -> Create New Test
勾选上要测试的方法，选择junit4，然后就会看到在test包下（这里前提是你用maven创建的项目）生成了那个类，
但是如果你这里用Alt + Insert 快捷键，也会构造出来，但是你会发现test包的输出路径不对。。。可以修改。
3.）在加了@Test方法中编写你的平时正常的逻辑代码，写完了后想运行单个方法的话，就右键方法，然后像平时运行main一样运行它，如果你是想运行整个类的话，就直接在类中右键运行；仅仅可以运行标注@Test的方法；
4.）创建方式有2种：
1.可以先写自己实现的方法，然后通过上述方法创建一个Test类来；
2.可以直接在test包下创建Test类，只不过@Test修饰的方法有要求：
必须是public void ,而且方法内无参数！

图文教程：
图文教程

慕课视频：
http://www.imooc.com/learn/356

然后就明白了我悟出的那句话：
1）不需要main（）也能运行某个方法、某个类，真的是方便-，-；
2）统一test包来管理这些test类。

三、代码实践

第一部分

入门使用

1.在pom.xml中加入依赖

<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>

2）我先写了个方法

/**
 * Author:林万新 lwx
 * Date:  2017/11/13
 * 计算加、减、乘、除的类
 */
public class Calcuate {
    public int add(int a,int b){
        return a+b;
    }
    public int subtract(int a,int b){
        return a-b;
    }
    public int multiply(int a,int b){
        return a*b;
    }
    public int divide(int a,int b){
        return a/b;
    }
}

3）使用Junit测试这个类中的方法

通过上述方法第1种方法逆向创建了一个相应的Test类，然后就可以使用Junit框架中的API来进行测试了。
/**
 * Author:林万新 lwx
 * Date:  2017/11/13
 * Time: 16:11
 * 使用规则：
 *  1.测试方法上必须使用@Test进行修饰
 *  2.测试方法必须使用public void 进行修饰，不能带任何的参数
 *  3.测试单元中的每个方法必须可以独立测试，测试方法间不能有任何的依赖
 *  命名规范:
 *  1.测试类使用Test作为类名的后缀
 *  2.测试方法使用test作为方法名的前缀
 */
public class CalcuateTest {
    //API之断言assertEquals的使用
    @Test
    public void add() throws Exception {
        //1:信息，2：期望值，3：实际值
        Assert.assertEquals("加法有问题", 7, new Calcuate().add(2,3));
    }
    @Test
    public void subtract() throws Exception {
        assertEquals(5,new Calcuate().subtract(7,2));
    }

    @Test
    public void multiply() throws Exception {
        assertEquals(6,new Calcuate().multiply(2,3));
    }

    @Test
    public void divide() throws Exception {
        assertEquals(3,new Calcuate().divide(6,2));
    }
}

运行结果：

可以看到运行了4个，1个失败，3个成功；

第2部分

API之其他注解的使用
直接在test包下创建一个普通类，这样子就可以直接在类中使用@Test等修饰了，就变成测试类了：

/**
 *
 * Author:林万新 lwx
 * Date:  2017/11/13
 * Time: 17:25
 * 1.@BeforeClass修饰的方法会有所有方法被调用前被执行，
 * 而且该方法是静态的，所以当测试类被加载后接着就会运行它，
 * 而且在内存中它只会存在一份实例，它比较适合加载配置文件。
 * 2.@AfterClass所修饰的方法通常用来对资源的清理，如关闭数据库的连接
 * 3.@Before和@After会在每个测试方法的前后各执行一次。
 */
public class JunitFlowTest {
    //这2个只可以静态的！不然报错！
    @BeforeClass
    public static void  setUpBeforeClassTest()throws Exception{
        System.out.println("this is  beforeClass");
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception{
        System.out.println("this is afterClass");
    }

    @Test
    public void test1() throws Exception {
        System.out.println("this is test1");
    }

    @Test
    public void test2() throws Exception{
        System.out.println("this is test2");
    }

    @Before
    public void setUp() throws Exception {
        System.out.println("this is before");
    }

    @After
    public void tearDown() throws Exception {
        System.out.println("this is after");
    }
}

运行结果：

第3部分

API之常用注解和属性的使用+断言的使用

/**
 * Author:林万新 lwx
 * Date:  2017/11/13
 * Time: 17:46
 *1.@Test:将一个普通的方法修饰成为一个测试方法
 2.@Test(expected=XXX（异常类）.class)：会抛出该异常
 3.@Test(timeout=毫秒 )：设置执行的时间，用于结束死循环或是性能测试
 4.@Ignore:所修饰的测试方法会被忽略
 */
public class AnotationTest {
    //预期抛出算术异常
    @Test(expected = ArithmeticException.class)
    public void testDivide() throws Exception {
        assertEquals(3,new Calcuate().divide(6,0));
    }
    @Ignore
    @Test(timeout = 10)
    public void testWhile() throws  Exception{
        while (true){
            System.out.println("死循环");
        }
    }
}

运行结果：

可以看到，1个被忽略，1个被正常运行。

第4部分

测试套件的使用：

/**
 * Author:林万新 lwx
 * Date:  2017/11/13
 * Time: 21:52
 * 1.测试套件就是组织测试类一起运行的
 写一个作为测试套件的入口类，这个类里不包含其它的方法
 更改测试运行器Suite.class
 将要测试的类作为数组传入到Suite.SuiteClasses({})
 */
@RunWith(Suite.class)
@Suite.SuiteClasses({AnotationTest.class,CalcuateTest.class,JunitFlowTest.class})
public class SuiteTest {
}

运行结果：

可以看到一下子运行了我们之前创建的3个类；多个类一口气运行；

第5部分

junit的参数化设置

/**
 * Author:林万新 lwx
 * Date:  2017/11/13
 * Time: 22:00
 * 1.更改默认的测试运行器为RunWith(Parameterized.class)
 2.声明变量来存放预期值和结果值
 3.声明一个返回值为Collection的公共静态方法，并使用@parameters进行修饰
 4.为测试类声明一个带有参数的公共构造函数，并在其中为之声明变量赋值
 */
@RunWith(Parameterized.class)
public class ParameterTest {
    int expected = 0;
    int input1 = 0;
    int input2 = 0;

    @Parameterized.Parameters
    public static Collection<Object[]> t(){
        return Arrays.asList(new Object[][]{
                {3,1,2},
                {4,2,2},
        });
    }

    public ParameterTest(int expected,int input1,int input2){
        this.expected = expected;
        this.input1 = input1;
        this.input2 = input2;
    }

    @Test
    public void testAdd(){
        assertEquals(expected,new Calcuate().add(input1,input2));
    }
}

运行结果：

可以看到一下子直接多次测试数据同一个方法；而不需要每次都为他写一个方法来依次测试；