Java 使用JUnit'；s@参数化，我可以让一些测试只运行一次吗

在许多情况下，我使用

@Parameterized

对许多排列运行测试。这工作得很好，并保持测试代码本身的简单和干净

然而，有时我希望一些测试方法仍然只运行一次，因为它们没有使用参数，JUnit有没有办法将测试方法标记为“单例”或“运行一次”

---

注意：这与在Eclipse中运行单个测试无关，我知道如何做到这一点：）

您可以使用一个套件将任意数量的测试类关联在一起运行。这样，当您测试类时，所有测试都会运行，您可以混合使用不同的测试运行程序

创建与正在测试的类关联的测试套件

添加对参数化测试类的引用

添加包含非参数化测试的其他类

import org.junit.runners.Suite;
import org.junit.runner.RunWith;

@RunWith(Suite.class)
@Suite.SuiteClasses({ParameterizedTestClass.class, UnitTests.class, MoreUnitTests.class})
public class SutTestSuite{
     //Empty...
}

---

有许多junit插件为您提供了更多关于参数化测试的特性/功能。检查zohhak、junit参数和junit数据提供程序。它们允许您混合使用参数化和简单的junit测试

您可以用它们来构造测试

在我了解“@RunWith（included.class）”方法之前，我使用了以下（类似的）解决方案，内部类扩展外部类。我一直使用这种结构，因为我喜欢测试在同一个地方，共享一些属性和方法，而且对我来说事情似乎更清楚。然后，使用Eclipse，在我的运行配置中，我选择“运行所选项目、包或源文件夹中的所有测试”选项，所有这些测试只需单击即可执行

public class TestBooksDAO {

    private static BooksDAO dao;

    @Parameter(0)
    public String title;
    @Parameter(1)
    public String author;

    @Before
    public void init() {
        dao = BooksDAO.getInstancia();
    }

    /** Tests that run only once. */
    public static class SingleTests extends TestBooksDAO {

        @Test(timeout=10000)
        public void testGetAll() {
            List<Book> books = dao.getBooks();
            assertNotNull(books);
            assertTrue(books.size()>0);
        }

        @Test(timeout=10000)
        public void testGetNone() {
            List<Book> books = dao.getBooks(null);
            assertNull(books);
        }
    }

    /** Tests that run for each set of parameters. */
    @RunWith(Parameterized.class)
    public static class ParameterizedTests1 extends TestBooksDAO {

        @Parameters(name = "{index}: author=\"{2}\"; title=\"{0}\";")
        public static Collection<Object[]> values() {
            return Arrays.asList(new Object[][] { 
                {"title1", ""}, 
                {"title2", ""}, 
                {"title3", ""}, 
                {"title4", "author1"}, 
                {"title5", "author2"}, 
            });
        }

        @Test(timeout=10000)
        public void testGetOneBook() {
            Book book = dao.getBook(author, title);
            assertNotNull(book);
        }
    }

    /** Other parameters for different tests. */
    @RunWith(Parameterized.class)
    public static class ParameterizedTests2 extends TestBooksDAO {

        @Parameters(name = "{index}: author=\"{2}\";")
        public static Collection<Object[]> values() {
            return Arrays.asList(new Object[][] { 
                {"", "author1"}, 
                {"", "author2"}, 
                {"", "author3"}, 
            });
        }

        @Test(timeout=10000)
        public void testGetBookList() {
            List<Book> books = dao.getBookByAuthor(author);
            assertNotNull(books);
            assertTrue(books.size()>0);
        }
    }
}

公共类TestBooksDAO{
私人静态书籍刀刀；
@参数（0）
公共字符串标题；
@参数（1）
公共字符串作者；
@以前
公共void init（）{
dao=BooksDAO.getInstancia（）；
}
/**只运行一次的测试*/
公共静态类SingleTests扩展了TestBooksDAO{
@测试（超时=10000）
公共void testGetAll（）{
List books=dao.getBooks（）；
资产（账簿）；
assertTrue（books.size（）>0）；
}
@测试（超时=10000）
公共void testGetNone（）{
List books=dao.getBooks（空）；
资产（账面）；
}
}
/**为每组参数运行的测试*/
@RunWith（参数化的.class）
公共静态类ParameteredTests1扩展了TestBooksDAO{
@参数（name=“{index}:author=\”{2}\“title=\“{0}\”；”）
公共静态集合值（）{
返回Arrays.asList（新对象[][]{
{“title1”，“”}，
{“标题2”，“”}，
{“标题3”，“}，
{“标题4”，“作者1”}，
{“标题5”，“作者2”}，
});
}
@测试（超时=10000）
public void testGetOneBook（）{
Book Book=dao.getBook（作者、书名）；
资产不为空（账面）；
}
}
/**不同测试的其他参数*/
@RunWith（参数化的.class）
公共静态类ParameteredTestS2扩展了TestBooksDAO{
@参数（name=“{index}:author=\”{2}\”；”）
公共静态集合值（）{
返回Arrays.asList（新对象[][]{
{“”“author1”}，
{“”“author2”}，
{“”“author3”}，
});
}
@测试（超时=10000）
public void testGetBookList（）{
List books=dao.getBookByAuthor（author）；
资产（账簿）；
assertTrue（books.size（）>0）；
}
}
}

听起来这些测试不应该与参数化测试在同一个套件中。是的，这是我想到的唯一解决方案，但我真的很喜欢在一个套件中进行“相关”测试，例如，一个测试类中的一个类的所有测试……是的，这可能就是我最终的结果，我希望会有类似于单一测试方法的注释…谢谢你的建议，这些看起来很有趣！美好的我不知道这件事。谢谢

public class TestBooksDAO {

    private static BooksDAO dao;

    @Parameter(0)
    public String title;
    @Parameter(1)
    public String author;

    @Before
    public void init() {
        dao = BooksDAO.getInstancia();
    }

    /** Tests that run only once. */
    public static class SingleTests extends TestBooksDAO {

        @Test(timeout=10000)
        public void testGetAll() {
            List<Book> books = dao.getBooks();
            assertNotNull(books);
            assertTrue(books.size()>0);
        }

        @Test(timeout=10000)
        public void testGetNone() {
            List<Book> books = dao.getBooks(null);
            assertNull(books);
        }
    }

    /** Tests that run for each set of parameters. */
    @RunWith(Parameterized.class)
    public static class ParameterizedTests1 extends TestBooksDAO {

        @Parameters(name = "{index}: author=\"{2}\"; title=\"{0}\";")
        public static Collection<Object[]> values() {
            return Arrays.asList(new Object[][] { 
                {"title1", ""}, 
                {"title2", ""}, 
                {"title3", ""}, 
                {"title4", "author1"}, 
                {"title5", "author2"}, 
            });
        }

        @Test(timeout=10000)
        public void testGetOneBook() {
            Book book = dao.getBook(author, title);
            assertNotNull(book);
        }
    }

    /** Other parameters for different tests. */
    @RunWith(Parameterized.class)
    public static class ParameterizedTests2 extends TestBooksDAO {

        @Parameters(name = "{index}: author=\"{2}\";")
        public static Collection<Object[]> values() {
            return Arrays.asList(new Object[][] { 
                {"", "author1"}, 
                {"", "author2"}, 
                {"", "author3"}, 
            });
        }

        @Test(timeout=10000)
        public void testGetBookList() {
            List<Book> books = dao.getBookByAuthor(author);
            assertNotNull(books);
            assertTrue(books.size()>0);
        }
    }
}