J'ai écrit une classe de test, telle que suit
public class MyParameterizedClassTest extends BaseRepositoryTest {
private int multiplierA;
private int multiplierB;
public MyParameterizedClassTest(int multiplierA) {
this.multiplierA = multiplierA;
}
@Parameters
public static Collection<Object[]> data() {
Object[][] data = new Object[][] { { 1 }, { 5 }, { 121 } };
return Arrays.asList(data);
}
@Test
public void testMultiplyException() {
assertEquals("Result", multiplierA * multiplierA,multiply(multiplierA));
}
public int multiply(int a){
return a*a;
}
}
Et ma classe BaseRepositoryTest suit
@RunWith (Parameterized. class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public abstract class BaseRepositoryTest extends
AbstractJUnit4SpringContextTests {
@Inject
SessionFactory sessionFactory;
private Transaction transaction;
public Session getSession() {
Session session;
try {
session = sessionFactory.getCurrentSession();
} catch (SessionException se) {
session = sessionFactory.openSession();
}
return session;
}
@Before
public void setUp() throws Exception {
transaction = getSession().beginTransaction();
}
@After
public void tearDown() throws Exception {
if (transaction != null) {
transaction.rollback();
}
getSession().close();
}
@Before
public void baseSetUp() {
MockitoAnnotations.initMocks(this);
}
}
Quand je cours ma classe de test, ça se voit,
Test class should have exactly one public zero-argument constructor:at
org.junit.runners.BlockJUnit4ClassRunner.validateZeroArgConstructor
Je veux faire une méthode de test avec @ paramètres, alors s'il vous plaît quelqu'un peut-il s'il vous plaît aider à trouver la solution
Je pense que le problème est que vous avez défini deux coureurs de test. Un par vous @RunWith (Parameterized. class)
et un qui vient avec le printemps, car un AbstractJUnit4SpringContextTests
définit un @RunWith(SpringJUnit4ClassRunner.class)
.
Comme Junit ne peut traiter qu’avec un seul @RunWith
, vous ne pouvez utiliser que @Parameterized
ou AbstractJUnit4SpringContextTests
. Si vous voulez utiliser les deux, vous devez utiliser @Parameterized
et faire la même logique que celle que SpringJUnit4ClassRunner
effectue vous-même.
Une approche simple consiste à utiliser simplement le org.springframework.test.context.TestContextManager
de spring.
@RunWith(Parameterized.class)
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
public abstract class BaseRepositoryTest extends AbstractJUnit4SpringContextTests {
private TestContextManager testContextManager;
@Before
public void setUpContext() throws Exception {
this.testContextManager = new TestContextManager(getClass());
this.testContextManager.prepareTestInstance(this);
}
}
Mais cela garantit uniquement que les TestExecutionListener
s sont invoqués. Normalement, Spring ressemble beaucoup plus à la mise en cache du contexte de l'application, etc. De plus, une méthode de démontage doit être mise en œuvre pour fermer le contexte de l'application.
Si vous exécutez un seul test, assurez-vous d'avoir écrit le nom de votre classe de test correctement.
Une erreur courante que je fais est d'avoir une classe nommée 'Foo' et une classe de test nommée
'FooTest'
et exécuter un seul test avec
'Foo'
au lieu de 'FooTest'
Si 'Foo' a un constructeur public avec des arguments, j'obtiens l'erreur:
Java.lang.Exception: Test class should have exactly one public zero-argument constructor
Essayez de supprimer le constructeur de MyParameterizedClassTest class.
J'avais cette erreur lorsque ma classe de test avait un constructeur public. Après avoir enlevé, ça a commencé à fonctionner.
Cette erreur est renvoyée lorsque votre classe n’est pas définie comme publique Dans votre cas, elle est abstraite, elle ne peut donc pas être instanciée pour les tests de propices.
J'ai une réponse, le problème est résolu sur ma machine JUnit4 -> quand vous vérifiez l'exception
org.junit.runners.BlockJUnit4ClassRunner.validateZeroArgConstructor(BlockJUnit4ClassRunner.Java:171)
org.junit.runners.BlockJUnit4ClassRunner.validateConstructor(BlockJUnit4ClassRunner.Java:148)
entrer à la première exception
protected void validateZeroArgConstructor(List<Throwable> errors) {
if(!this.getTestClass().isANonStaticInnerClass() && this.hasOneConstructor() && this.getTestClass().getOnlyConstructor().getParameterTypes().length != 0) {
String gripe = "Test class should have exactly one public zero-argument constructor";
errors.add(new Exception(gripe));
}
}
il vérifiera si votre constructeur n'est pas paramétré ou non Essayez l'injection de setter ou le champ (-> le champ n'est pas recommandé officiellement)