Day14：单元测试、Junit单元测试框架、反射、注解

于 2024-03-06 21:51:19 发布
阅读量837 收藏 23
点赞数 24
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43303286/article/details/136518989
版权

单元测试

  • 针对最小的功能单元（方法）进行正确性测试
  • 编写正规的单元测试框架
  • 传统的无法执行自动化测试，且无法得到测试报告

Junit单元测试框架

  • Junit的作用：

image

具体步骤

image

  • 测试类取名：原类名+Test（大驼峰）
  • 测试方法取名：test+原函数名称（小驼峰）
  • 测试方法：必须public，无参，无返回值
  • 测试方法上面必须加上@Test方法，不加不会跑的
  • 测试方法只能判断程序能否正常运行，并不能判断功能是否正确，需要加断言（Assert）
public class StringUtilTest {
    @Test // 测试方法
    public void testPrintNumber(){
//        StringUtil.printNumber("admin");
        StringUtil.printNumber(null);
    }
}

公共的（Public）：JUnit框架在运行测试时，需要能够访问到测试方法。如果测试方法不是公共的，JUnit框架可能无法访问到它，从而无法执行测试。

无参数的：JUnit框架在运行测试时，会自动调用测试方法，而不需要手动传入参数。如果测试方法需要参数，JUnit框架无法知道应该传入什么值，因此，测试方法不能有参数。

无返回值的（Void）：JUnit框架通过断言（Assert）来检查测试是否通过，而不是通过返回值。因此，测试方法不需要返回值。

Assert断言（重要）

@Test // 测试方法
    public void testGetMaxIndex(){
        int index1 = StringUtil.getMaxIndex(null);
        System.out.println(index1);

        int index2 = StringUtil.getMaxIndex("admin");
        System.out.println(index2);

        // 断言机制：程序员可以通过预测业务方法的结果。
        Assert.assertEquals("方法内部有bug!", 4, index2);
    }
  • Assert.assertEquals(提示信息，希望的输出，实际输出）

自动化测试

  • 自动化测试：IDEA中直接右键run就行（run整个类就是run所有有Test注解的方法）。
  • 右键项目 run all_tests,测试所有

其他常见注解

image

public class StringUtilTest {
    @Before //每次测试类的每个方法之前都执行一次
    public void test1(){
        System.out.println("---> test1 Before 执行了---------");
    }

    @BeforeClass //整个类只执行一次
    public static void test11(){
        System.out.println("---> test11 BeforeClass 执行了---------");
    }

    @After
    public void test2(){
        System.out.println("---> test2 After 执行了---------");
    }

    @AfterClass
    public static void test22(){
        System.out.println("---> test22 AfterClass 执行了---------");
    }

    @Test // 测试方法
    public void testPrintNumber(){
//        StringUtil.printNumber("admin");
        StringUtil.printNumber(null);
    }
}
  • 在JUnit 5之后改名了：

image

反射

  • 作用：加载类，并编程解析类中的各种成分（比如成员变量、方法、构造器等）
  • 关键：如何获取类的各种信息

image

加载类

  • 三种方法：

image

（方法三必须先new一个对象才能得到对应的类的class对象）

public static void main(String[] args) throws Exception {
        Class c1 = Student.class;
        System.out.println(c1.getName()); // 全类名
        System.out.println(c1.getSimpleName()); // 简名：Student

        Class c2 = Class.forName("com.itheima.d2_reflect.Student");
        System.out.println(c1 == c2);

        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c3 == c2);
    }

(forName的参数应该是类的全类名：包名.类名）

获取类的构造器

  • 不加Declare只能拿public的，加了就都能拿
  • 拿单个构造器应该表明参数类型（String.class, int.class)（不然不知道是纳哪个构造器）
  • 拿单个的时候会报异常，可以throws抛出

image

public void testGetConstructors(){
        // 1、反射第一步：必须先得到这个类的Class对象
        Class c = Cat.class;
        // 2、获取类的全部构造器
        // Constructor[] constructors = c.getConstructors();
        Constructor[] constructors = c.getDeclaredConstructors();
        // 3、遍历数组中的每个构造器对象
        for (Constructor constructor : constructors) {
            System.out.println(constructor.getName() + "--->"
            + constructor.getParameterCount());
        }
    }

Constructor constructor1 = c.getDeclaredConstructor();//无参构造器

// 3、获取有参数构造器
Constructor constructor2 = c.getDeclaredConstructor(String.class, int.class);

获取构造器的作用：初始化对象返回（相当于new）

image

newInstance 初始化对象

Cat cat2 = (Cat) constructor2.newInstance("叮当猫", 3);

找到对应的构造器，相当于new一个对象（实际开发还是用new），这里注意需要强转(Cat)

setAccessible 修改权限（暴力反射）

// 3、获取有参数构造器
Constructor constructor2 =
        c.getDeclaredConstructor(String.class, int.class);
System.out.println(constructor2.getName() + "--->"
        + constructor2.getParameterCount());
constructor2.setAccessible(true); // 禁止检查访问权限
Cat cat2 = (Cat) constructor2.newInstance("叮当猫", 3);
System.out.println(cat2);

将原本private的构造器硬在外部禁止检查访问权限，无论如何都会new出一个对象。

获取类的成员变量

  • 反射第一步：得到class对象
  • 其他跟构造器的差不多，包括declare，setAccessible等
  • getName拿到名字，getType拿到数据类型

image

public void testGetFields() throws Exception {
        // 1、反射第一步：必须是先得到类的Class对象
        Class c = Cat.class;
        // 2、获取类的全部成员变量。
        Field[] fields = c.getDeclaredFields();
        // 3、遍历这个成员变量数组
        for (Field field : fields) {
            System.out.println(field.getName() +  "---> "+ field.getType());
        }
        // 4、定位某个成员变量
        Field fName = c.getDeclaredField("name");
        System.out.println(fName.getName() + "--->" + fName.getType());

        Field fAge = c.getDeclaredField("age");
        System.out.println(fAge.getName() + "--->" + fAge.getType());

    }

获取成员变量的作用：赋值（set）和取值（get）

// 赋值
        Cat cat = new Cat();
        fName.setAccessible(true); // 禁止访问控制权限
        fName.set(cat, "卡菲猫");
        System.out.println(cat);

        // 取值
        String name = (String) fName.get(cat);
        System.out.println(name);
  • 必须有对象才能有对象的成员变量
  • set（变量名，值）
  • get（对象名），需要强转。

setAccessible 修改权限（暴力反射）

fName.setAccessible(true); // 禁止访问控制权限

获取类的成员方法

  • getName拿方法名，getParameterCount拿参数个数，getReturnType拿返回类型
  • getDeclaredMethod要写参数类型，不然不知道找的是哪个同名函数

image

public void testGetMethods() throws Exception {
        //  1、反射第一步：先得到Class对象。
        Class c = Cat.class;
        // 2、获取类的全部成员方法。
        Method[] methods = c.getDeclaredMethods();
        // 3、遍历这个数组中的每个方法对象
        for (Method method : methods) {
            System.out.println(method.getName() + "--->"
                    + method.getParameterCount() + "---->"
                    + method.getReturnType());
        }
        //  4、获取某个方法对象
        Method run = c.getDeclaredMethod("run", String.class); // 拿run方法，无参数的

获取类方法的作用：执行invoke

image

Cat cat = new Cat();
run.setAccessible(true); // 禁止检查访问权限
Object rs = run.invoke(cat); // 调用无参数的run方法，用cat对象触发调用的。
//这里无返回值则返回null
System.out.println(rs);

eat.setAccessible(true); // 禁止检查访问权限
String rs2 = (String) eat.invoke(cat, "鱼儿");
System.out.println(rs2);

反射的应用场景

image

示例

image

框架：

public class ObjectFrame {
    // 目标：保存任意对象的字段和其数据到文件中去
    public static void saveObject(Object obj) throws Exception {
        PrintStream ps = new PrintStream(new FileOutputStream("junit-reflect-annotation-proxy-app\\src\\data.txt", true));
        // obj是任意对象，到底有多少个字段要保存。
        Class c = obj.getClass();
        String cName = c.getSimpleName();
        ps.println("---------------" + cName + "------------------------");
        // 2、从这个类中提取它的全部成员变量
        Field[] fields = c.getDeclaredFields();
        // 3、遍历每个成员变量。
        for (Field field : fields) {
            // 4、拿到成员变量的名字
            String name = field.getName();
            // 5、拿到这个成员变量在对象中的数据。
            field.setAccessible(true); // 禁止检查访问控制
            String value = field.get(obj) + "";
            ps.println(name + "=" + value);
        }
        ps.close();
    }
}

测试：

public class Test5Frame {
    @Test
    public void save() throws Exception {
        Student s1 = new Student("黑马吴彦祖", 45, '男', 185.3, "蓝球，冰球，阅读");
        Teacher t1 = new Teacher("播妞", 999.9);

        // 需求：把任意对象的字段名和其对应的值等信息，保存到文件中去。
        ObjectFrame.saveObject(s1);
        ObjectFrame.saveObject(t1);
    }
}

注解（Annotation）

  • java中的特殊标记
  • 作用：让其他程序根据注解信息决定怎么执行该程序。
  • 可以用在类上、构造器上、方法上、成员变量上、参数上等。

自定义注解

image

/**
 * 自定义注解
 */
public @interface MyTest1 {
    String aaa();
    boolean bbb() default true;
    String[] ccc();
}

如何使用？

@MyTest1(aaa="牛魔王", ccc={"HTML", "Java"})

public class AnnotationTest1 {
    @MyTest1(aaa="铁扇公主", bbb=false, ccc={"Python", "前端", "Java"})
    public void test1(){

    }

    public static void main(String[] args) {

    }
}

（有参数的一定要填，有默认参数的不必须要填）

特殊属性名：value

  • 如果注解中只有一个value属性（或多余的数值为默认值default），使用@注解时可以不写value名称
public @interface MyTest2 {
    String value(); // 特殊属性
    int age() default 23;
}


@MyTest2("孙悟空")
public class AnnotationTest1 {
    @MyTest1(aaa="铁扇公主", bbb=false, ccc={"Python", "前端", "Java"})
    public void test1(){

    }

    public static void main(String[] args) {

    }
}

注解的原理：本质是一个接口！！！

  • 把注解编译成class再反

image

  • 本质是一个继承Annotation接口的接口！！!
  • 使用注解时创建实现类对象，把参数传进去

元注解

  • 定义：修饰注解的注解
  • 常见：@Target和Retention

@Target

image

  • TYPE：比如Field（变量），TYPE（类）等，多个用{,}隔开
@Target({ElementType.TYPE, ElementType.METHOD}) // 当前被修饰的注解只能用在类上，方法上。
public @interface MyTest3 {
}

@MyTest3
public class AnnotationTest2 {

    // @MyTest3 这里会报错
    private String name;

    @MyTest3
    public void test(){

    }
}

Retention

image

@Retention(RetentionPolicy.RUNTIME) // 控制下面的注解一直保留到运行时
public @interface MyTest3 {
}
  • RUNTIME:一直保留到运行阶段（常用）

注解的解析

  • 定义：判断类上/方法上等上是否存在注解，并把注解里的内容解析出来
  • 方法

image

解析案例

image

MyTest4:

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTest4 {
   String value();
   double aa() default 100;
   String[] bbb();
}

Demo:

@MyTest4(value = "蜘蛛精", aaa=99.5, bbb = {"至尊宝", "黑马"})
@MyTest3
public class Demo {
    @MyTest4(value = "孙悟空", aaa=199.9, bbb = {"紫霞", "牛夫人"})
    public void test1(){
    }
}

AnnotationTest3:

public class AnnotationTest3 {
    @Test
    public void parseClass(){
        // 1、先得到Class对象
        Class c = Demo.class;
        // 2、解析类上的注解
        // 判断类上是否包含了某个注解
        if(c.isAnnotationPresent(MyTest4.class)){//这里是.class而不是直接输出类
            MyTest4 myTest4 =
                    (MyTest4) c.getDeclaredAnnotation(MyTest4.class);
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(Arrays.toString(myTest4.bbb()));
        }
    }

    @Test
    public void parseMethod() throws Exception {
        // 1、先得到Class对象
        Class c = Demo.class;
        Method m = c.getDeclaredMethod("test1");
        // 2、解析方法上的注解
        // 判断方法对象上是否包含了某个注解
        if(m.isAnnotationPresent(MyTest4.class)){
            MyTest4 myTest4 =
                    (MyTest4) m.getDeclaredAnnotation(MyTest4.class);
            System.out.println(myTest4.value());
            System.out.println(myTest4.aaa());
            System.out.println(Arrays.toString(myTest4.bbb()));
        }
    }
}

应用场景

  • 与反射配合做框架

示例

image

image

定义MyTest注解：

@Target(ElementType.METHOD) // 注解只能注解方法。
@Retention(RetentionPolicy.RUNTIME) // 让当前注解可以一直存活着。
public @interface MyTest {
}

定义若干个方法：

public class AnnotationTest4 {
    // @MyTest 不会被执行
    public void test1(){
        System.out.println("===test1====");
    }

    @MyTest
    public void test2(){
        System.out.println("===test2====");
    }

    @MyTest
    public void test3(){
        System.out.println("===test3====");
    }

    @MyTest
    public void test4(){
        System.out.println("===test4====");
    }

    public static void main(String[] args) throws Exception {
        .......
        }
    }
}

模拟Junit程序：通过反射配合注解解析

public static void main(String[] args) throws Exception {
        AnnotationTest4 a = new AnnotationTest4();
        // 启动程序！
        // 1、得到Class对象
        Class c = AnnotationTest4.class;
        // 2、提取这个类中的全部成员方法
        Method[] methods = c.getDeclaredMethods();
        // 3、遍历这个数组中的每个方法，看方法上是否存在@MyTest注解，存在
        // 触发该方法执行。
        for (Method method : methods) {
            if(method.isAnnotationPresent(MyTest.class)){
                // 说明当前方法上是存在@MyTest，触发当前方法执行。
                method.invoke(a);
            }
        }
    }

调用结果：

image

  • 1、得到Class对象
  • 2、提取这个类中的全部成员方法
  • 3、遍历这个数组中的每个方法，看方法上是否存在@MyTest注解，执行（必须创建对象，重新new一个）

动态代理

  • 意义：对象身上事儿太多，需要通过代理转移部分职责；
  • 含义：对象有什么方法想被代理，代理也得有，但不真正做，而是一些其他操作+调用对象的。
  • 怎么做：对象声明接口，代理设置实现类。
  1. 接口：
public interface Star {
    String sing(String name);
    void dance();
}
  1. 用明星类实现该接口：
public class BigStar implements Star{
    private String name;

    public BigStar(String name) {
        this.name = name;
    }

    public String sing(String name){
        System.out.println(this.name + "正在唱：" + name);
        return "谢谢！谢谢！";
    }

    public void dance(){
        System.out.println(this.name  + "正在优美的跳舞~~");
    }
}
  1. 让代理类实现该接口ProxyUtil（工具类，静态方法）
import java.lang.reflect.Proxy;

public class ProxyUtil {
    public static Star createProxy(BigStar bigStar){
       .......
        return starProxy;
    }
}

newProxyInstance:

 newProxyInstance(ClassLoader loader,
                Class<?>[] interfaces,
                InvocationHandler h)
                参数1：用于指定一个类加载器
                参数2：指定生成的代理长什么样子，也就是有哪些方法(接收的接口数组)
                参数3：用来指定生成的代理对象要干什么事情（new一个接口的匿名内部类对象）

Star starProxy = (Star) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
                new Class[]{Star.class}, new InvocationHandler() {
                    @Override // 回调方法
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 代理对象要做的事情，会在这里写代码
                        if(method.getName().equals("sing")){
                            System.out.println("准备话筒，收钱20万");
                        }else if(method.getName().equals("dance")){
                            System.out.println("准备场地，收钱1000万");
                        }
                        return method.invoke(bigStar, args);
                    }
                });

回调方法invoke

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 代理对象要做的事情，会在这里写代码
                        if(method.getName().equals("sing")){//当前正在代理sing方法
                            System.out.println("准备话筒，收钱20万");
                        }else if(method.getName().equals("dance")){
                            System.out.println("准备场地，收钱1000万");
                        }
                        return method.invoke(bigStar, args);//返回方法的返回值
                    }
  • proxy：代理对象
  • method：方法；
  • args：方法的参数

如何调用？test：

public class Test {
    public static void main(String[] args) {
        BigStar s = new BigStar("杨超越");
        Star starProxy = ProxyUtil.createProxy(s);

        String rs = starProxy.sing("好日子");
        System.out.println(rs);

        starProxy.dance();
    }
}

(可通过单步调试追踪调用链条）

应用场景：AOP

动态代理设计模式主要用于以下几种场景：

  1. 接口适配：当一个类已经实现了某个接口，但是需要对该接口的某些方法进行修改时，可以使用动态代理。动态代理可以在不修改原有代码的情况下，对接口的方法进行增强。
  2. AOP（面向切面编程）：动态代理是实现AOP的一种方式。在AOP中，通常会在业务方法执行前后插入一些公共的代码，如日志、事务管理等。动态代理可以在运行时动态地为目标对象生成一个代理对象，然后通过代理对象调用目标方法，从而实现在目标方法执行前后插入公共代码。
  3. 远程调用：在远程方法调用（RMI）中，客户端实际上是调用的是本地的一个代理对象，这个代理对象负责与远程服务器通信。这个代理对象就是通过动态代理生成的。
  4. 权限控制：动态代理可以用于实现权限控制。例如，当调用某个方法时，可以通过动态代理检查用户是否有权限执行该方法。
  5. 性能监控：动态代理可以用于监控方法的执行时间，从而实现性能监控。例如，可以在方法执行前后获取系统时间，然后计算出方法的执行时间。
  6. 单元测试：在单元测试中，经常需要模拟一些对象。这些模拟对象可以通过动态代理生成。例如，可以生成一个代理对象，这个代理对象的所有方法都返回默认值。
    什么是AOP？

**面向切面编程（Aspect-Oriented Programming，AOP）**是一种编程范式，其目标是提高模块化的能力，特别是对于横切关注点（cross-cutting concerns）的处理。横切关注点是那些分散在多个模块中，但不能很好地通过传统的面向对象编程（OOP）模块化的问题，例如日志记录、事务管理、安全性等。

在AOP中，一个切面（Aspect）代表一个横切关注点，它可以包含一些通用的代码。这些代码可以被定义为通知（Advice），然后通过切入点（Pointcut）插入到目标对象的方法中。通知定义了何时（例如，方法调用前、后或异常抛出时）以及如何（执行何种代码）应用切面。

例如，你可能有一个用于记录日志的切面，它的通知在每个方法调用前后记录日志，切入点定义了这个切面应用于哪些方法。

AOP可以帮助我们将这些横切关注点从业务逻辑中分离出来，使得业务逻辑更加清晰，同时也更易于维护和重用。

QHG7C0
关注
  • 24
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
软件单元测试——JUnit使用
08-15
用Eclipse进行软件单元测试，具体步骤和示例。
单元测试及JUnit的应用
登登的博客 是温馨的小屋。
05-31 1030
我们通过单元测试工具Junit、代码静态工具FindBugs、一级代码复杂度检测工具SourceMonitor的使用，我了解到在编写和运行可重复的测试上，一些特性：如测试代码和产品代码分开。一些测试框架的编写，都可以使代码的编写更的方便；而对于代码的静态检测工具FindBugs是支持Java的，但我了解到更多的静态检测工具：像支持c++的Parasoft C++ Test,也知道了FindBugs实际是扫描和分析Java字节码（.class文件），在记忆中我加深了对软件的使用技巧；
单元测试(JUnit)的应用
stay hungry ! stay foolish!
03-29 2099
单元测试(JUnit)的应用一、  概要单元测试不仅仅是保证代码在方法级别的正确性，它还能改进设计，易于对代码重构。凡是容易编写单元测试的代码，往往是优秀的设计和松耦合的组件，凡是难于编写单元测试的代码，往往是设计不佳和耦合度高的系统，因此，编写单元测试不仅仅是掌握单元测试框架的用法，更重要的是在编写单元测试的过程中发现设计缺陷，改进系统结构，从而实现良好的可扩展性。任何一个项目，单元测试应该在详...
单元测试——JUnit介绍和应用
醉染
08-01 763
1.写测试类的原则  测试方法上必须使用@Test进行修饰；  测试方法必须使用public void 进行修饰，不能带任何的参数；  新建一个源代码目录来存放我们的测试代码；  测试类的包应该和被测试类的包保持一致；  测试单元中的每个方法必须可以独立测试，测试方法间不能有任何的依赖；  测试类使用Test作为类名的后缀（不是必须）；  测试方法使用test作为方法名的前缀（不是必须） 2.测...
单元测试方法Junit的使用
qq_43788522的博客
03-08 422
步骤 当前工程 - 右键选择：build path - add libraries - JUnit 4 - 下一步 点击next即可，然后下面会多出Junit4。 创建Java类，进行单元测试。 此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器 此类中声明单元测试方法（一般都以testXxx()格式命名）。 此时的单元测试方法：方法的权限是public,没返回值，没形参。 4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：impor
day24_枚举_注解_反射.pdf
11-02
Junit是一个流行的Java单元测试框架，它允许程序员编写测试代码来验证被测试代码的功能。Junit属于白盒测试，关注程序的内部逻辑。使用Junit时，我们需要在测试方法上添加`@Test`注解，并确保方法无参数且返回值为`...
day01_基础加强_docx1
08-04
总之，Java 中的 JUnit 提供了高效、简便的单元测试机制，反射使得程序能够在运行时动态访问和修改类信息，而注解则为代码提供了额外的元信息，增强了代码的可读性和可维护性。掌握这些知识点对于 Java 开发者来说至...
day01_基础加强笔记.md
10-05
### Junit单元测试 #### 测试分类 - **黑盒测试**：这是一种无需了解程序内部结构的测试方式，仅需给定输入值并检查程序是否能输出预期的结果。 - **白盒测试**：与之相对的是白盒测试，它需要深入了解程序的具体...
F2019_Day2
02-22
10. **单元测试和调试**：介绍JUnit等测试工具的使用，以及如何有效地调试Java程序。 【标签】"Java"确认了这次活动的焦点在于Java编程语言，可能涵盖从初学者到进阶者所需的各种技能和知识。 【压缩包子文件的...
Java_day20上课资料.zip
04-01
8. **Junit测试**：JUnit是Java中最常用的单元测试框架，用于编写和执行测试用例。学生会学习如何编写断言，设置测试条件，以及使用@Test注解进行测试。 9. **Lambda表达式**：自Java 8开始引入的lambda表达式简化...
【Spring Boot实战与进阶】单元测试JUnit的使用
程序员云帆哥的博客
11-09 1933
JUnit是一款优秀的开源Java单元测试框架，也是目前使用率最高最流行的测试框架，开发工具Eclipse和IDEA对JUnit都有很好的支持，JUnit主要用于白盒测试和回归测试。
Junit单元测试学习以及使用
小轩的名古屋
06-19 1668
一、什么是单元测试 在平时的开发当中，一个项目往往包含了大量的方法，可能有成千上万个。如何去保证这些方法产生的结果是我们想要的呢？当然了，最容易想到的一个方式，就是我们通过System.out来输出我们的结果，看看是不是满足我们的需求，但是项目中这些成千上万个方法，我们总不能在每一个方法中都去输出一遍嘛。这也太枯燥了。这时候用我们的单元测试框架junit就可以很好地解决这个问题。Junit是一个单元测试框架。 二、使用 注意：用Junit进行单元测试必须满足以下条件： 1、每一个测试方法上使用@Test进行
Java中Junit单元测试的使用
m0_71987537的博客
06-14 258
本文介绍了Java中如何使用单元测试方法
junit单元测试应用实例
weixin_43448751的博客
05-12 202
转自 :https://www.jianshu.com/p/a3fa5d208c93 如有侵权,请联系撤销转载
Junit单元测试下载、配置、使用
最新发布
qq_71443736的博客
11-13 2759
​什么是Junit单元测试？ JUnit 是一个 Java 编程语言的单元测试框架。JUnit 在测试驱动的开发方面有很重要的发展，是起源于 JUnit的一个统称为 xUnit 的单元测试框架之一。所谓 xUnit,就是一套基于测试驱动开发的测试框架，它的机制：将程序预期的结果与程序运行的最终结果进行比对，确保对结果的可预知性。
单元测试工具——JUnit的使用
如风暖阳的博客
02-16 4929
单元测试工具——JUnit的使用
软件测试--应用JUnit进行单元测试
weixin_45949840的博客
04-25 5926
一、实验原理 JUnit是一个开源的Java编程语言的单元测试框架，最初由 Erich Gamma 和 Kent Beck 编写。Junit测试是一种白盒测试工具。JUnit是一套框架，继承TestCase类，就可以用Junit进行自动测试了。具有JUnit经验对于应用“测试驱动开发（TDD）”的程序开发模型是非常重要的。 JUnit本质上是一套框架，即开发者制定了一套条条框框，遵循这此条条框框要求编写测试代码，如继承某个类，实现某个接口，就可以用JUnit进行自动测试了。 　　由于JUnit相对独立于所编
单元测试Junit使用与详解
熊與貓v
08-20 2477
当然了，最容易想到的一个方式，就是我们通过System.out来输出我们的结果，看看是不是满足我们的需求，但是项目中这些成千上万个方法，我们总不能在每一个方法中都去输出一遍嘛。在这里选择assertEquals(Object expected,Object actual)，expected指的是期望得到的值，actual指实际返回的结果，如果期望值和实际结果不相等，就会抛异常，即断言失败。我们对add方法进行测试，代码如下。断言判断是否相等，这个方法里面可以又很多参数，一般根据我们的需要输入相应的参数。
单元测试Junit使用详解
赵英超的博客
03-22 1478
1、Junit 是什么？ 　　JUnit是一个Java语言的单元测试框架。它由Kent Beck和Erich Gamma建立，逐渐成为源于Kent Beck的sUnit的xUnit家族中最为成功的一个JUnit有它自己的JUnit扩展生态圈。多数Java的开发环境都已经集成了JUnit作为单元测试的工具。 　　注意：Junit 测试也是程序员测试，即所谓的白盒测试，它需要程序员知道被测试的代码...
JUnit设计模式：单元测试框架的模式应用分析
JUnit是一个广泛使用的Java单元测试框架，由Erich Gamma和Kent Beck这两位软件设计大师合作创建。它基于XUnit测试框架的理念，旨在简化测试代码的编写，确保测试的持久性，并能利用现有测试来扩展新的测试用例。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值