Question

我写了一个简单的类，其中第一个函数的输出是第二个函数的输入，第二个函数的输出是第三个函数的输入。之后，我将这些输出打印在另一个实现JUnit @Test案例的类中。

但是为了调用第二个函数的测试，我得到'res'值为null（应该输出第一个函数并将其作为输入传递给第二个函数）。第三种功能也是如此。

我将'res'声明为全局变量。那么为什么它的值变为null而不是保持第一个函数的结果然后是第二个函数的结果（用于调用第三个函数）？

这是包含3个函数的类：

package con.nc.junitexmples.Junit4Examples;

public class StringExample {

 public static String firstFunction() {

    String msg1 = "msg1";
    return msg1;

}

public static String secondFunction(String msg1) {

    String msg2 = msg1+"msg2";
    return msg2;

}

public static String thirdFunction(String msg2) {

    String msg3= msg2+"msg3";
    return msg3;

  }

}

这是实现JUnit @Test案例和打印输出的类：

package con.nc.junitexmples.Junit4Examples;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;

@FixMethodOrder(MethodSorters.NAME_ASCENDING)

public class TestStringExample {

String res;

  @BeforeClass  
    public static void setUpBeforeClass() throws Exception {  
      System.out.println("\n\t\t-----JUnit cascading input Example------\n\n");  
      System.out.println("before class---->only once");  


    }  
    @Before  
    public void setUp() throws Exception {  
        System.out.println("\nbefore--->before each test case");  
    }  

    @Test  
    public void testFirstFunction(){  
        System.out.println("\ttest case: FIRST Function");  

        res = StringExample.firstFunction();
        System.out.println("\t"+res);

    }  

    @Test  
    public void testSecondFunction(){  
        System.out.println("\ttest case: SECOND Function");  

        res = StringExample.secondFunction(res);
        System.out.println("\t"+res);

    }  

    @Test  
    public void testThirdFunction(){  
        System.out.println("\ttest case: THIRD Function");  

        res = StringExample.thirdFunction(res);
        System.out.println("\t"+res);

    }  


    @After  
    public void tearDown() throws Exception {  
        System.out.println("after ---> after each test case\n\n");  
    }  

    @AfterClass  
    public static void tearDownAfterClass() throws Exception {  
        System.out.println("after class--->only once");  
    }  

}

这是我得到的输出：

    -----JUnit cascading input Example------


 before class---->only once

 before--->before each test case
     test case: FIRST Function
     msg1
 after ---> after each test case



 before--->before each test case
     test case: SECOND Function
    **nullmsg2** 
 after ---> after each test case



 before--->before each test case
    test case: THIRD Function
     **nullmsg3**
 after ---> after each test case


after class--->only once

如何将第一个函数的结果作为输入传递给第二个？等等？

Answer 1

这些测试中的每一个都是独立的，独立的，并且在这些测试方法开始时res的值为null。

所以，这就解释了为什么你会看到：

nullmsg2
nullmsg3

鉴于上述评论中的这个问题：

如何将第一个函数的输出作为输入传递给第二个函数进行第二次测试？

您可以在一个测试方法中测试所有三个调用，如下所示：

@Test
public void testAll() {
    String res = StringExample.firstFunction();
    Assert.assertEquals("msg1", res);

    res = StringExample.secondFunction(res);
    Assert.assertEquals("msg1msg2", res);

    res = StringExample.thirdFunction(res);
    Assert.assertEquals("msg1msg2msg3", res);
}

Answer 2

用于将第一个函数的结果传递给第二个函数：

    @Test  
    public void testSecondFunction(){  
        System.out.println("\ttest case: SECOND Function");  
        String resFromFirstFunc = StringExample.firstFunction();
        res = StringExample.secondFunction(resFromFirstFunc);
        System.out.println("\t"+res);

    }

但你不应该像上面的例子一样编写测试，它总是通过。你应该使用：

Assert.assertEquals(input,output)

全局变量的值在JUnit中变为null

2 个答案: