Meilleur moyen de migrer automatiquement les tests de JUnit 3 vers JUnit 4 ?

Question

J'ai un tas de classes JUnit 3 qui étendent TestCase et je voudrais les migrer automatiquement vers des tests JUnit4 avec des annotations telles que @Before , @After , @Test etc.
Existe-t-il un outil permettant de faire cela dans un grand lot ?

Answer 1

À mon avis, cela ne doit pas être si difficile. Alors essayons :

0. Importations

Vous devez importer trois annotations :

import org.junit.After;
import org.junit.Before;
import org.junit.Test;`

Après avoir fait les quelques changements suivants, vous n'aurez plus besoin import junit.framework.TestCase; .

1. Annotez test* Méthodes

Toutes les méthodes commençant par public void test doit être précédé de la mention @Test annotation. Cette tâche est facile avec une regex.

2. Annoter les méthodes SetUp et TearDown

Eclipse génère ce qui suit setUp() méthode :

@Override
protected void setUp() throws Exception { }

Doit être remplacé par :

@Before
public void setUp() throws Exception { }

Idem pour tearDown() :

@Override
protected void tearDown() throws Exception { }

remplacé par

@After
public void tearDown() throws Exception { }

3. Se débarrasser de extends TestCase

Supprimer exactement une occurence par fichier de la chaîne de caractères

" extends TestCase"

4. Supprimer les méthodes principales ?

Il est probablement nécessaire de supprimer/refaire les méthodes principales existantes qui exécuteront le test.

5. Convertir suite() pour @RunWithClass

Selon le commentaire de saua, il doit y avoir une conversion de la suite() méthode. Merci, saua !

@RunWith(Suite.class)
@Suite.SuiteClasses({
  TestDog.class
  TestCat.class
  TestAardvark.class
})

Conclusion

Je pense que cela se fait très facilement via un jeu d'expressions régulières, même si cela va me tuer le cerveau ;)

Answer 2

Voici les expressions régulières réelles que j'ai utilisées pour exécuter les suggestions de furtelwart :

// Add @Test
Replace:
^[ \t]+(public +void +test)
With:
    @Test\n    $1
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Remove double @Test's on already @Test annotated files
Replace:
^[ \t]+@Test\n[ \t]+@Test
With:
    @Test
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Remove all empty setUp's
Replace:
^[ \*]+((public|protected) +)?void +setUp\(\)[^\{]*\{\s*(super\.setUp\(\);)?\s*\}\n([ \t]*\n)?
With nothing
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Add @Before to all setUp's
Replace:
^([ \t]+@Override\n)?[ \t]+((public|protected) +)?(void +setUp\(\))
With:
    @Before\n    public void setUp()
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Remove double @Before's on already @Before annotated files
Replace:
^[ \t]+@Before\n[ \t]+@Before
With:
    @Before
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Remove all empty tearDown's
Replace:
^[ \*]+((public|protected) +)?void +tearDown\(\)[^\{]*\{\s*(super\.tearDown\(\);)?\s*\}\n([ \t]*\n)?
With nothing
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Add @After to all tearDown's
Replace:
^([ \t]+@Override\n)?[ \t]+((public|protected) +)?(void +tearDown\(\))
With:
    @After\n    public void tearDown()
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Remove double @After's on already @After annotated files
Replace:
^[ \t]+@After\n[ \t]+@After
With:
    @After
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Remove old imports, add new imports
Replace:
^([ \t]*import[ \t]+junit\.framework\.Assert;\n)?[ \t]*import[ \t]+junit\.framework\.TestCase;
With:
import org.junit.After;\nimport org.junit.Before;\nimport org.junit.Test;\nimport static org.junit.Assert.*;
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Remove all extends TestCase
Replace:
[ \t]+extends[ \t]+TestCase[ \t]+\{
With:
 {
Regular Expression: on
Case sensitive: on
File name filter:
*Test.java

// Look for import junit.framework;
Find:
import junit\.framework
Manually fix
Regular Expression: on
Case sensitive: on

// Look for ignored tests (FIXME, disabled, ...)
Find:
public[ \t]+void[ \t]+\w+test
Manually fix
Regular Expression: on
Case sensitive: on

// Look for dummy/empty tests
Find:
public[ \t]+void[ \t]+test[\w\d]*\(\s*\)\s*\{\s*(//[^\n]*)?\s*\}
Manually fix
Regular Expression: on
Case sensitive: on

Remarque : il est important de les faire dans l'ordre indiqué ci-dessus.

Answer 3

Nous sommes au milieu de la migration d'une base de code assez importante vers JUnit4. Comme c'est la deuxième fois que je fais une migration de ce type, j'ai décidé de sauvegarder le code quelque part :

https://github.com/FranciscoBorges/junit3ToJunit4

Il traite d'autres cas de figure que ceux énumérés dans les réponses ci-dessus. Par exemple :

• appels à TestCase.setUp() et TestCase.tearDown()
• appels à TestCase(String) dans le constructeur d'une sous-classe
• appels à TestCase.assert* qui sont passés à Assert .
• Correction des noms de paquets junit.framework à org.junit
• etc.

Answer 4

Je ne connais pas d'outil qui puisse faire cela pour le moment - je m'attends à ce qu'Eclipse fournisse un plugin assez rapidement - mais vous pourriez créer une classe Java simple d'exploration de l'arbre source qui le ferait pour vous si vous voulez seulement faire une conversion de base. J'ai dû écrire quelque chose de similaire pour générer automatiquement des cas de test squelettiques pour une ancienne application, j'ai donc déjà une bonne partie du code de support. Vous êtes le bienvenu pour l'utiliser.

Answer 5

Il n'existe pas (encore), à ma connaissance, d'outils de migration disponibles. Ce que je sais, c'est ceci :

• L'année dernière, à l'OOPSLA de Nashville, il y a eu un article sur la migration des API mais, hélas, leurs outils ne semblent pas être ouvertement disponibles. Je vais fournir le lien vers le document (même si je pense qu'il ne vous sera pas d'une grande utilité car il est plutôt théorique) : "Annotation Refactoring : Inférer les transformations de mise à niveau pour les applications patrimoniales". .

• Ci-dessus, j'ai écrit "aucun outil disponible (pour le moment)" parce que mon étudiante Lea Hänsenberger travaille actuellement sur une migration API auotmée de, non seulement, JUnit 4 a à JExample, mais aussi de JUnit 3 à JUnit 4. S'il vous plaît suivez JExample sur Twitter pour être prévenu quand elle publiera une première version bêta.

J'espère que ces informations vous ont été utiles.