Java: Comment les méthodes de test que le Système d'appel.exit()?

En effet, Derkeiler.com suggère:

• Pourquoi System.exit() ?

Au lieu de rompre avec le Système.sortie(whateverValue), pourquoi ne pas jeter un décoché exception? En utilisation normale, il ne dérive pas tous le moyen de sortir de la JVM ultime catcher et d'éteindre votre script en bas (sauf si vous décidez de l'attraper quelque part le long du chemin, ce qui pourrait être utile un jour).

Dans la JUnit scénario, il sera pris par le framework JUnit, qui rendra compte que
tel-et-tel test a échoué et se déplacer en douceur le long de la prochaine.

• Empêcher System.exit() pour réellement sortir de la JVM:

Essayer de modifier les cas de test à exécuter avec un gestionnaire de sécurité qui empêche le Système d'appel.exit, puis prendre le SecurityException.

public class NoExitTestCase extends TestCase 
{
protected static class ExitException extends SecurityException 
{
public final int status;
public ExitException(int status) 
{
super("There is no escape!");
this.status = status;
}
}
private static class NoExitSecurityManager extends SecurityManager 
{
@Override
public void checkPermission(Permission perm) 
{
//allow anything.
}
@Override
public void checkPermission(Permission perm, Object context) 
{
//allow anything.
}
@Override
public void checkExit(int status) 
{
super.checkExit(status);
throw new ExitException(status);
}
}
@Override
protected void setUp() throws Exception 
{
super.setUp();
System.setSecurityManager(new NoExitSecurityManager());
}
@Override
protected void tearDown() throws Exception 
{
System.setSecurityManager(null); //or save and restore original
super.tearDown();
}
public void testNoExit() throws Exception 
{
System.out.println("Printing works");
}
public void testExit() throws Exception 
{
try 
{
System.exit(42);
} catch (ExitException e) 
{
assertEquals("Exit status", 42, e.status);
}
}
}

---

Mise À Jour De Décembre 2012:

Va propose dans les commentaires à l'aide de Système de Règles, une collection de JUnit(4.9+) règles pour la vérification du code qui utilise java.lang.System.

Il a d'abord été mentionné par Stefan Birkner dans sa réponse en décembre 2011.

System.exit(…)

Utiliser le ExpectedSystemExit règle pour vérifier que System.exit(…) est appelé.

Vous pouvez vérifier le statut de sortie, trop.

Par exemple:

public void MyTest {
@Rule
public final ExpectedSystemExit exit = ExpectedSystemExit.none();
@Test
public void noSystemExit() {
//passes
}
@Test
public void systemExitWithArbitraryStatusCode() {
exit.expectSystemExit();
System.exit(0);
}
@Test
public void systemExitWithSelectedStatusCode0() {
exit.expectSystemExitWithStatus(0);
System.exit(0);
}
}

Vous fait peut simulé ou stub les System.exit méthode, dans un test JUnit.

Par exemple, à l'aide de JMockit vous pouvez écrire (il y a d'autres façons):

@Test
public void mockSystemExit(@Mocked("exit") System mockSystem)
{
//Called by code under test:
System.exit(); //will not exit the program
}

EDIT: test de remplacement (en utilisant les dernières JMockit API) qui ne permettent pas de code à exécuter après un appel à System.exit(n):

@Test(expected = EOFException.class)
public void checkingForSystemExitWhileNotAllowingCodeToContinueToRun() {
new Expectations(System.class) {{ System.exit(anyInt); result = new EOFException(); }};
//From the code under test:
System.exit(1);
System.out.println("This will never run (and not exit either)");
}

Un truc que nous avons utilisé dans notre base de code était d'avoir l'appel Système.exit() être encapsulé dans un Exécutable impl, que la méthode en question est utilisé par défaut. À l'unité de test, nous avons mis une autre maquette Praticable. Quelque chose comme ceci:

private static final Runnable DEFAULT_ACTION = new Runnable(){
public void run(){
System.exit(0);
}
};
public void foo(){ 
this.foo(DEFAULT_ACTION);
}
/* package-visible only for unit testing */
void foo(Runnable action){   
//...some stuff...   
action.run(); 
}

...et la méthode de test JUnit...

public void testFoo(){   
final AtomicBoolean actionWasCalled = new AtomicBoolean(false);   
fooObject.foo(new Runnable(){
public void run(){
actionWasCalled.set(true);
}   
});   
assertTrue(actionWasCalled.get()); 
}

Créer une maquette en mesure de classe qui encapsule le Système.exit()

Je suis d'accord avec EricSchaefer. Mais si vous utilisez un bon moqueur cadre comme Mockito une simple classe de béton est suffisant, pas besoin d'une interface et des deux implémentations.

Essai de l'arrêt de l'exécution sur le Système.exit()

Problème:

//do thing1
if(someCondition) {
System.exit(1);
}
//do thing2
System.exit(0)

Un moqué Sytem.exit() de ne pas interrompre l'exécution. C'est mauvais si vous voulez tester que thing2 n'est pas exécutée.

Solution:

Vous devriez refactoriser ce code comme suggéré par martin:

//do thing1
if(someCondition) {
return 1;
}
//do thing2
return 0;

Et ne System.exit(status) dans la fonction appelante. Cela vous oblige à avoir tous vos System.exit()s en un seul endroit dans ou à proximité de main(). C'est plus propre que de faire appel System.exit() profondément à l'intérieur de votre logique.

Code

Wrapper:

public class SystemExit {
public void exit(int status) {
System.exit(status);
}
}

Principal:

public class Main {
private final SystemExit systemExit;
Main(SystemExit systemExit) {
this.systemExit = systemExit;
}
public static void main(String[] args) {
SystemExit aSystemExit = new SystemExit();
Main main = new Main(aSystemExit);
main.executeAndExit(args);
}
void executeAndExit(String[] args) {
int status = execute(args);
systemExit.exit(status);
}
private int execute(String[] args) {
System.out.println("First argument:");
if (args.length == 0) {
return 1;
}
System.out.println(args[0]);
return 0;
}
}

Test:

public class MainTest {
private Main       main;
private SystemExit systemExit;
@Before
public void setUp() {
systemExit = mock(SystemExit.class);
main = new Main(systemExit);
}
@Test
public void executeCallsSystemExit() {
String[] emptyArgs = {};
//test
main.executeAndExit(emptyArgs);
verify(systemExit).exit(1);
}
}

Vous pouvez utiliser le java SecurityManager pour empêcher le thread en cours d'arrêt de la machine virtuelle Java. Le code suivant devrait faire ce que vous voulez:

SecurityManager securityManager = new SecurityManager() {
public void checkPermission(Permission permission) {
if ("exitVM".equals(permission.getName())) {
throw new SecurityException("System.exit attempted and blocked.");
}
}
};
System.setSecurityManager(securityManager);

Il existe des environnements où l'renvoyé le code de sortie est utilisé par le programme appelant (comme ERRORLEVEL dans MS Lot). Nous avons des tests sur les principales méthodes de le faire dans notre code, et notre approche a été d'utiliser un SecurityManager remplacer celle utilisée dans d'autres tests ici.

La nuit dernière j'ai mis en place un petit POT en utilisant Junit @Règle des annotations pour masquer le gestionnaire de sécurité code, ainsi que d'ajouter des attentes fondées sur le rendement attendu de code. http://code.google.com/p/junitsystemrules/

Système D'Appel.exit() est une mauvaise pratique, sauf si c'est fait à l'intérieur d'une main(). Ces méthodes devraient être lancer une exception qui, en fin de compte, est capturé par votre main(), qui appelle ensuite le Système.sortie avec le code approprié.

Il y a un petit problème avec le SecurityManager solution. Certaines méthodes, telles que JFrame.exitOnClose, aussi appel SecurityManager.checkExit. Dans mon application, je ne voulais pas que l'appel à l'échec, j'ai donc utilisé

Class[] stack = getClassContext();
if (stack[1] != JFrame.class && !okToExit) throw new ExitException();
super.checkExit(status);