junit test（testng和junit有什么优缺点，该如何选择）

本文目录

• testng和junit有什么优缺点，该如何选择
• JUnit test 如何做Java静态方法测试
• junit如何测试访问数据库的类
• Java Junit Test 要怎么写
• 为什么使用Junit Test而不用普通java main方法来完成测试
• Junit4中怎样随心所欲的执行Test
• junit4.11 怎么使用@test

testng和junit有什么优缺点，该如何选择

结论是两者差不多，一般人用用testng就好。
原因：1.testng底层调用junit
2.历史上曾有testng优于junit的一段时期，但随后junit已更新并追赶上来
3.testng的data provider使用较方便
4.testng能做的事情junit都能做，但是有的地方会比较麻烦，例如，数据驱动，多线程并发执行测试用例。testng更便捷，自带。junit则要依靠第三方工具提供。
5.junit能做的事情testng也都能做，但junit也有更便捷的时候。比如soft assertion，junit可以直接继承jassert做，testng你要自己去实现静态类来做。
6.junit是testng的底层，灵活度上更高。testng调用junit，对测试员来说用户体验更好。

JUnit test 如何做Java静态方法测试

使用junit测试Java静态私有方法，通过以下案例进行分析：

测试目标类如下：

package cn.outofmemory.junit;
public class TestTarget {
    /**
     * 移除正则表达式中需要转义的字符
     * @param w word
     * @return 移除正则表达式中需要转义的字符
     * @author Administrator
     * @date 2015-7-11
     */
    private static String convert4Regex(String w) {
        if (w == null) {
            return null;
        }
        String convertedChars = {“\\“,“.“,“+“,“*“,“(“,“)“,“{“,“}“,“[“,“]“,“?“,“/“,“^“,“$“,“|“};
        for (String c : convertedChars) {
            w = w.replace(c, “\\“ + c);
        }
        return w;
    }
}

测试方法：

@Test
public void testConvert4Regex() throws Exception {
        String input = “A+“;
        String expected = “A\\+“;
        Method targetMethod = TestTarget.class.getDeclaredMethod(“convert4Regex“, String.class);
        targetMethod.setAccessible(true);
        Object actual = targetMethod.invoke(TestTarget.class, new Object{input});
        assertEquals(expected,actual);
    }

junit如何测试访问数据库的类

关于junit单元测试工具的安装请参看第二课的内容（其实就是导入一个junit的jar包就行了）
首先认识几个注解标签
@Test:测试方法
@Before：初始化方法
@After：释放资源
执行顺序：@Before-》@Test-》@After
第一步新建测试文件夹（目的就是用来存放测试类，使项目更整洁，分类明确，好管理）
选中项目右键new-》Source Folder 输入文件夹的名称例如test
在测试文件夹下创建测试类（就是创建个普通的类）
如下在测试类中使用junit进行单元测试
下面只是先搭建一个测试框架
搭建好之后测试hibernate访问数据库的代码注意：导入的包不要弄错，都是hibernate的包
public class StudentTest { private SessionFactory sessionFactory; private Session session; private Transaction transaction; @Before public void init(){ //创建配置对象 Configuration config = new Configuration(); //创建服务注册对象 ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(config.getProperties()).buildServiceRegistry(); //创建会话工厂对象 sessionFactory = config.buildSessionFactory(serviceRegistry); //会话对象 session = sessionFactory.openSession(); //开启事务 transaction = session.beginTransaction(); } @Test public void testSaveStudents(){ Student s = new Student(1, “小明“, new Date(), “北京xxxx街道5号楼201“); session.save(s);//保存对象到数据库 } @After public void destory(){ transaction.commit();//提交事务 session.close();//关闭会话 sessionFactory.close();//关闭会话工厂 }}
进行测试如下： 选中测试方法右键run as -》junit test就行了
执行成功控制台打印信息：
查看数据库表
可以看到增加了一条信息，测试成功

Java Junit Test 要怎么写

一般不用写，直接测试方法，在测试的方法上加上注解@Test

import org.junit.Test;
public class TestJunit {
    @Test
    public void TestSaveMethod(){
    Food food=new Food(“红烧肉“, new BigDecimal(45.5).setScale(2, BigDecimal.ROUND_HALF_UP), “hsr.jpg“);
        SaveFood(food);
    }
    
    
    public void SaveFood(Food food){
       if(food!=null){
        food.setId(UUID.randomUUID().toString());
        System.out.println(“Food Save is OK!“);
        System.out.println(“当前ID：“+food.getId()+“   名称：“+food.getName()+“   单价：“+food.getPrice());
      }else{
       System.out.println(“Food Save is False!“);
      }
    
    }
}
class Food implements Serializable{
    private String id;
    private String name;
    private BigDecimal price;
    private String icon;    
    
    public Food(String name,BigDecimal price,String icon) {
        this.name=name;
        this.price=price;
        this.icon=icon;        
    }
    public void setId(String id) {
        this.id = id;
    }
    
    public String getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public BigDecimal getPrice() {
        return price;
    }
    public String getIcon() {
        return icon;
    }
}
//这样的话RUN 的时候就会出现JUnit测试

为什么使用Junit Test而不用普通java main方法来完成测试

因为在程序里边，一个接口对应一个实现方法，而在接口中常常会定义相关的很多方法，所以在测试的时候，如果都在main方法里边进行测试，main方法就会显得臃肿，而且不便于以后其他人测试以及查看测试数据，用Junit Test测试的话，一个方法对应一个测试方法，简单明了，也方便别人查看测试方法以及测试数据。

Junit4中怎样随心所欲的执行Test

使用的是junit4.4，想要有选择性的执行TestCase中的Test，是需要自己扩展junit4.4的API的。junit4.8的版本中，加入了一个Runner:Categories,可以实现只跑特定分类的Test。现在通过代码举例来比较两个版本中批量执行Test的差别.
public class TestOne {

@Test
public void testOne1(){
System.out.println(“TestOne 1“);
}

@Category({RunCases.class}) ----Junit4.8中才有的注解
@Test
public void testOne2(){
System.out.println(“TestOne 2“);
}
}
public class TestTwo {

@Test
public void testTwo1(){
System.out.println(“TestTwo 1“);
}

@Category(RunCases.class) ----Junit4.8中才有的注解
@Test
public void testTwo2(){
System.out.println(“TestTwo 2“);
}
}
junit4.4中，使用Suite批量执行Test： TestOne.class,TestTwo.class中的Test会全部被执行，实现如下：
@RunWith(Suite.class)
@SuiteClasses({
TestOne.class,
TestTwo.class})
public class AllTestCases {
}
junit4.8中，使用Categories批量执行Test：可以有选择的执行SuiteClasses中的部分Test，实现如下：
在TestCase的Test前加上@Category(RunCases.class) 注解，RunCases.class是自定义分类类型（可以是class，也可以是interface，名称没有特殊要求）；
public class RunCases {
}
或
public interface RunCases{
}
然后，我们使用@Runwith来指定使用Categories测试引擎，并且使用@IncludeCategory或@ExcludeCategory指定哪些测试用例被执行:
@RunWith(Categories.class)
@IncludeCategory(RunCases.class)
@SuiteClasses({TestOne.class,TestTwo.class})
public class TestPartExcute {
}
执行结果：
TestOne 2
TestTwo 2
@RunWith(Categories.class)
@ExcludeCategory(RunCases.class)
@SuiteClasses({TestOne.class,TestTwo.class})
public class TestPartExcute {
}
执行结果：
TestOne 1
TestTwo 1
注意事项说明：
1.@Category({RunCases.class}) 注解用在测试用例类上，并不能生效；
2.可以定义多个分类类型，在@Category注解中，可以使用多个分类类型，eg：@Category({A.class，B.class})；
3.@IncludeCategory或@ExcludeCategory注解中出现的类型，必须在@Category注解中出现过，否则执行会报错。
附带：Junit4各版本新特性汇总
Junit源码(github)地址：git://github.com/KentBeck/junit.git

JUnit 4.4
主要提供了以下三个大方面的新特性来更好的抓住编程人员的代码意图：
1.提供了新的断言语法（Assertion syntax）——assertThat
2.提供了假设机制（Assumption）
3.提供了理论机制（Theory）
JUnit 4.5
Runner实现发生了较大改变，废弃了原来的JUnit4ClassRunner，改用BlockJUnit4ClassRunner替代。新的runner机制更容易扩展和重用，可在测试执行流程中方便的切入加入新的特性。
JUnit 4.6
该版本提升了核心的体系结构,允许对测试进行重新排序以及并行处理等。
Junit 4.7
该版本增加了一个重要的新特性：Rule,同时添加了很多核心Rule：
TemporaryFolder：测试可以创建文件与目录并且会在测试运行结束后将其删除。这对于那些与文件系统打交道且独立运行的测试来说很有用。
ExternalResource：这是一种资源使用模式，它会提前建立好资源并且会在测试结束后将其销毁。这对于那些使用socket、嵌入式服务器等资源的测试来说很有用。
ErrorCollector：可以让测试在失败后继续运行并在测试结束时报告所有错误。这对于那些需要验证大量独立条件的测试来说很有用（尽管这本身可能是个“test smell”）。
ExpectedException：可以在测试中指定期望的异常类型与消息。
Timeout：为类中的所有测试应用相同的超时时间。
Junit 4.8
加入了一个Runner:Categories,可以只跑特定分类的测试用例。
Junit 4.9
Test-class and suite level Rules。
Maven support
Junit 4.10
The RuleChain rule allows ordering of TestRules。

junit4.11 怎么使用@test

Junit4支持注解了，只要在要执行的方法前加@Test即可，如：
@Test
public void multiplyPoundsByInteger() {
assertEquals( 10, 5 );
}
Junit4增加了许多特性，主要是支持注解了：
测试由原来的命名模式改变注解，即testXXX变为@Test。其中@Test还提供了额外的属性。如expected，表示期望抛出的异常
数组比较改用Assert.assertArrayEquals
套件测试也用注解替换
通过@Ignore，可以忽略某个方法或整个类的测试
增加了新特性-理论机制（Theory）,这个特性听起来很迷惑人,作用是使得开发人员从开始的定义测试用例的阶段就可以通过参数集（理论上是无限个参数）对代码行为进行概括性的总结.开发人员都知道他们代码所想要实现的概括性的总的目的，理论使得他们只需要在一个地方就可以快速的指定这些目的，而不要将这些目的翻译成大量的独立的测试用例。
提供了新的特性-假设机制（Assumption）.此特性使用了Hamcrest库的类.本来Hamcrest是一个单独的测试组件,Junit也集成了一部分，但是并没有完全包含。建议使用junit独立的JAR文件，再单独引入hamcrest包。 其实hamcrest的功能相当的强大，理解起来也非常的容易，是一个很不错的组件。它提供assertThat,assumeThat，assumeNotNull等假设语句，也提供is,not,both..and,either..or等用法，非常的灵活。
@Before,@After,@BeforeClass,@AfterClass.这几个注解一看便知大概，@Before表示每个测试方法执行前执行一次，而@BeforeClass表示整个类测试前执行一次。不过需要注意的是，@BeforeClass,@AtferClass注解的方法必须是静态的。
Junit提供了新的核心运行类MaxCore，相对于以前的JunitCore运行机制，这个类有一系列的优点，如从未测试过的方法优先测试，剩下的测试中，以前测试失败的方法优先测试，再其次，运行快的优先于运行慢的方法。
参数化测试 允许通过变化范围的参数值来测试方法。
超时测试（Timeout test）可以被用来测试方法的执行时间。
Rule。它是JUnit4.7才开始提供的一种扩展方式，它能够替代大部分已有的Runner扩展。JUnit包含两种Rule Annotation：@ClassRule与@Rule。@ClassRule应用于测试类中的静态变量，而@Rule应用于成员变量；相同地是，这些变量必须是TestRule接口的实例，且访问修饰符必须为public。