Question

我有一个测试用例，它提供参数并执行类的主要方法。使用Junit让多个线程可以执行类的主要方法的最佳方法是什么。

Answer 1

不确定TestNG是否适合您，但它非常简单：

@Test(invocationCount = 100, threadPoolSize = 10)
public void myTest() { ... }

这将导致从10个不同的线程调用100次测试方法。如果这个测试通过并且你经常运行它，你可以相当确信被测代码是多线程安全的。

Answer 2

你为什么这样做？您的public static void main(String []) 真的是由多个线程运行的吗？似乎是一个奇怪的设计，这就是我确定的原因。

另一方面，如果你想测试你的程序的并行执行（所以每个都在一个单独的JVM中），它与多线程不同，JUnit也不会这样做，因为它在同一个JVM中执行。你仍然可以做到这一点，没问题，但要确保你知道差异。

关于SO的一些例子：

Concurrent JUnit testing
How do I test a concurrent Java program which expects cmd line arguments?（在单独的JVM中执行并行测试的其他一些工具）

Answer 3

这是一个轻量级的解决方案：

以下是您要测试的课程：

Test ob=new Test(5);

这是Test类。这将在JUnit框架中调用。重写multiTest（）方法。包mTTest;

package mTTest;

/**
 * UUT class is the Unit Under Test. This will be tested.
 * It has two simple method:
 *  push(): sets the message string if it's null, and waits otherwise. 
 *  pop():  if there is any message sets it null and returns it.
 *
 */
public class UUT {
    String message = null;

    synchronized void push(String msg){
        while (null != message) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        message = msg;
        notifyAll();
    }

    synchronized String pop(){
        while (null == message) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        String ret = message;
        message = null;
        notifyAll();
        return ret;
    }


}

这是Thread，可以多次调用。覆盖test（）方法。

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.ListIterator;

import org.junit.Test;

/**
 * This is the JUnit test class. Method in this class will invoked by the JUnit
 * framework.
 */
public class DUTTest {

    /**
     * Stores sub test threads errors.
     */
    private static List<AssertionError> errors;

    /**
     * sub test threads call this function with they errors.
     * @param err
     */
    static void handle(AssertionError err){
        errors.add(err);
    }

    /**
     * Simpler single thread test
     * @throws InterruptedException
     */
    @Test
    public void testSingle() {
        UUT dut = new UUT();

        dut.push("hello");

        assertEquals("set-get", "hello", dut.message);
    }


    /**
     * Complex multi-thread test
     * @throws InterruptedException
     */
    @Test
    public void testMulti() throws Exception {
        /*
         * Initialization
         */
        errors = Collections.synchronizedList(new ArrayList<AssertionError>());
        UUT dut = new UUT();
        MyTestThread th = new MyTestThread(dut);

        /*
         * Tests
         */
        dut.push("hello");

        assertEquals("set-get", "hello", dut.message);

        th.start();

        dut.push("hello");

        th.join();

        /*
         * Error handling 
         */
        ListIterator<AssertionError> iter = errors.listIterator(errors.size());

        while (iter.hasPrevious()) {
            AssertionError err = iter.previous();
            err.printStackTrace();
            if(iter.previousIndex() == -1){
                throw err;
            }
        }
    }


}

Junit多线程

3 个答案: