Java: comment tester les méthodes qui appellent System.exit ()?

J'ai quelques méthodes qui devraient faire appel System.exit()à certaines entrées. Malheureusement, le test de ces cas entraîne l'arrêt de JUnit! Placer les appels de méthode dans un nouveau thread ne semble pas aider, car System.exit()met fin à la JVM, pas seulement au thread actuel. Existe-t-il des schémas communs pour gérer cela? Par exemple, puis-je remplacer un talon pour System.exit()?

[EDIT] La classe en question est en fait un outil en ligne de commande que j'essaie de tester dans JUnit. Peut-être que JUnit n'est tout simplement pas le bon outil pour le travail? Les suggestions d'outils de test de régression complémentaires sont les bienvenues (de préférence quelque chose qui s'intègre bien avec JUnit et EclEmma).

En effet, Derkeiler.com propose:

• Pourquoi System.exit()?

Au lieu de terminer avec System.exit (quelle que soit la valeur), pourquoi ne pas lever une exception non vérifiée? En utilisation normale, il dérivera jusqu'au dernier récupérateur de la JVM et fermera votre script (sauf si vous décidez de l'attraper quelque part en cours de route, ce qui pourrait être utile un jour).

Dans le scénario JUnit, il sera intercepté par le framework JUnit, qui signalera que tel ou tel test a échoué et se déplacera en douceur vers le suivant.

• Prévenir System.exit() de quitter réellement la JVM:

Essayez de modifier le TestCase pour qu'il s'exécute avec un gestionnaire de sécurité qui empêche d'appeler System.exit, puis interceptez 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:

Will propose dans les commentaires à l' aide de System Rules , une collection de règles JUnit (4.9+) pour tester le code qui utilise java.lang.System.
Cela a été initialement mentionné par Stefan Birkner dans sa réponse de décembre 2011.

System.exit(…)

Utilisez la ExpectedSystemExitrègle pour vérifier qu'elle System.exit(…)est appelée.
Vous pouvez également vérifier l'état de sortie.

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);
    }
}

La bibliothèque System Lambda a une méthode. catchSystemExitAvec cette règle vous pouvez tester le code, qui appelle System.exit (...):

public void MyTest {
    @Test
    public void systemExitWithArbitraryStatusCode() {
        SystemLambda.catchSystemExit(() -> {
            //the code under test, which calls System.exit(...);
        });
    }
}

Pour Java 5 à 7, les règles système de la bibliothèque ont une règle JUnit appelée ExpectedSystemExit. Avec cette règle, vous pouvez tester le code qui appelle System.exit (...):

public void MyTest {
    @Rule
    public final ExpectedSystemExit exit = ExpectedSystemExit.none();

    @Test
    public void systemExitWithArbitraryStatusCode() {
        exit.expectSystemExit();
        //the code under test, which calls System.exit(...);
    }

    @Test
    public void systemExitWithSelectedStatusCode0() {
        exit.expectSystemExitWithStatus(0);
        //the code under test, which calls System.exit(0);
    }
}

Divulgation complète: je suis l'auteur des deux bibliothèques.

Que diriez-vous d'injecter un "ExitManager" dans ces méthodes:

public interface ExitManager {
    void exit(int exitCode);
}

public class ExitManagerImpl implements ExitManager {
    public void exit(int exitCode) {
        System.exit(exitCode);
    }
}

public class ExitManagerMock implements ExitManager {
    public bool exitWasCalled;
    public int exitCode;
    public void exit(int exitCode) {
        exitWasCalled = true;
        this.exitCode = exitCode;
    }
}

public class MethodsCallExit {
    public void CallsExit(ExitManager exitManager) {
        // whatever
        if (foo) {
            exitManager.exit(42);
        }
        // whatever
    }
}

Le code de production utilise ExitManagerImpl et le code de test utilise ExitManagerMock et peut vérifier si exit () a été appelé et avec quel code de sortie.

Vous pouvez réellement vous moquer ouSystem.exit méthode, dans un test JUnit.

Par exemple, en utilisant JMockit, vous pourriez écrire (il existe également d'autres moyens):

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

EDIT: Test alternatif (utilisant la dernière API JMockit) qui ne permet à aucun code de s'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)");
}

Une astuce que nous avons utilisée dans notre base de code était d'avoir l'appel à System.exit () être encapsulé dans un implément Runnable, que la méthode en question utilisé par défaut. Pour le test unitaire, nous avons défini un Runnable simulé différent. Quelque chose comme ça:

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éez une classe factice qui enveloppe System.exit ()

Je suis d'accord avec EricSchaefer . Mais si vous utilisez un bon cadre moqueur comme Mockito une simple classe concrète suffit, pas besoin d'une interface et de deux implémentations.

Arrêt de l'exécution des tests sur System.exit ()

Problème:

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

Un simulé Sytem.exit()ne mettra pas fin à l'exécution. C'est mauvais si vous voulez tester qui thing2n'est pas exécuté.

Solution:

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

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

Et faites System.exit(status)dans la fonction d'appel. Cela vous oblige à avoir tous vos System.exit()s en un seul endroit dans ou à proximité main(). C'est plus propre que d'appeler System.exit()profondément dans votre logique.

Code

Wrapper:

public class SystemExit {

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

Principale:

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;
    }
}

Tester:

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);
    }
}

J'aime certaines des réponses déjà données, mais je voulais démontrer une technique différente qui est souvent utile lors de la mise à l'essai du code hérité. Étant donné le code comme:

public class Foo {
  public void bar(int i) {
    if (i < 0) {
      System.exit(i);
    }
  }
}

Vous pouvez effectuer une refactorisation sûre pour créer une méthode qui encapsule l'appel System.exit:

public class Foo {
  public void bar(int i) {
    if (i < 0) {
      exit(i);
    }
  }

  void exit(int i) {
    System.exit(i);
  }
}

Ensuite, vous pouvez créer un faux pour votre test qui remplace la sortie:

public class TestFoo extends TestCase {

  public void testShouldExitWithNegativeNumbers() {
    TestFoo foo = new TestFoo();
    foo.bar(-1);
    assertTrue(foo.exitCalled);
    assertEquals(-1, foo.exitValue);
  }

  private class TestFoo extends Foo {
    boolean exitCalled;
    int exitValue;
    void exit(int i) {
      exitCalled = true;
      exitValue = i;
    }
}

Il s'agit d'une technique générique pour substituer le comportement aux cas de test, et je l'utilise tout le temps lors de la refactorisation du code hérité. Ce n'est généralement pas là où je vais laisser quelque chose, mais une étape intermédiaire pour tester le code existant.

Un rapide coup d'œil à l'API, montre que System.exit peut lever une exception esp. si un gestionnaire de sécurité interdit l'arrêt du VM. Une solution serait peut-être d'installer un tel gestionnaire.

Vous pouvez utiliser le java SecurityManager pour empêcher le thread actuel d'arrêter 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);

Pour que la réponse de VonC s'exécute sur JUnit 4, j'ai modifié le code comme suit

protected static class ExitException extends SecurityException {
    private static final long serialVersionUID = -1982617086752946683L;
    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);
    }
}

private SecurityManager securityManager;

@Before
public void setUp() {
    securityManager = System.getSecurityManager();
    System.setSecurityManager(new NoExitSecurityManager());
}

@After
public void tearDown() {
    System.setSecurityManager(securityManager);
}

Vous pouvez tester System.exit (..) en remplaçant l'instance Runtime. Par exemple avec TestNG + Mockito:

public class ConsoleTest {
    /** Original runtime. */
    private Runtime originalRuntime;

    /** Mocked runtime. */
    private Runtime spyRuntime;

    @BeforeMethod
    public void setUp() {
        originalRuntime = Runtime.getRuntime();
        spyRuntime = spy(originalRuntime);

        // Replace original runtime with a spy (via reflection).
        Utils.setField(Runtime.class, "currentRuntime", spyRuntime);
    }

    @AfterMethod
    public void tearDown() {
        // Recover original runtime.
        Utils.setField(Runtime.class, "currentRuntime", originalRuntime);
    }

    @Test
    public void testSystemExit() {
        // Or anything you want as an answer.
        doNothing().when(spyRuntime).exit(anyInt());

        System.exit(1);

        verify(spyRuntime).exit(1);
    }
}

Il existe des environnements où le code de sortie renvoyé est utilisé par le programme appelant (tel que ERRORLEVEL dans MS Batch). Nous avons des tests sur les principales méthodes qui le font dans notre code, et notre approche a été d'utiliser un remplacement SecurityManager similaire à celui utilisé dans d'autres tests ici.

Hier soir, j'ai monté un petit JAR en utilisant les annotations Junit @Rule pour masquer le code du gestionnaire de sécurité, ainsi que pour ajouter des attentes basées sur le code de retour attendu. http://code.google.com/p/junitsystemrules/

La plupart des solutions

• terminer le test (méthode, pas la totalité du cycle) le moment System.exit()est appelé
• ignorer un déjà installé SecurityManager
• Parfois, être assez spécifique à un framework de test
• restreindre pour être utilisé au maximum une fois par scénario de test

Ainsi, la plupart des solutions ne conviennent pas aux situations où:

• La vérification des effets secondaires doit être effectuée après l'appel à System.exit()
• Un gestionnaire de sécurité existant fait partie des tests.
• Un cadre de test différent est utilisé.
• Vous souhaitez avoir plusieurs vérifications dans un même scénario de test. Cela peut être strictement déconseillé, mais peut parfois être très pratique, en particulier en combinaison avec assertAll(), par exemple.

Je n'étais pas satisfait des restrictions imposées par les solutions existantes présentées dans les autres réponses, et j'ai donc trouvé quelque chose par moi-même.

La classe suivante fournit une méthode assertExits(int expectedStatus, Executable executable)qui affirme qu'elle System.exit()est appelée avec un spécifiéstatus valeur et le test peut continuer après. Cela fonctionne de la même manière que JUnit 5assertThrows . Il respecte également un gestionnaire de sécurité existant.

Il reste un problème: lorsque le code sous test installe un nouveau gestionnaire de sécurité qui remplace complètement le gestionnaire de sécurité défini par le test. Toutes les autres SecurityManagersolutions à ma connaissance connaissent le même problème.

import java.security.Permission;

import static java.lang.System.getSecurityManager;
import static java.lang.System.setSecurityManager;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;

public enum ExitAssertions {
    ;

    public static <E extends Throwable> void assertExits(final int expectedStatus, final ThrowingExecutable<E> executable) throws E {
        final SecurityManager originalSecurityManager = getSecurityManager();
        setSecurityManager(new SecurityManager() {
            @Override
            public void checkPermission(final Permission perm) {
                if (originalSecurityManager != null)
                    originalSecurityManager.checkPermission(perm);
            }

            @Override
            public void checkPermission(final Permission perm, final Object context) {
                if (originalSecurityManager != null)
                    originalSecurityManager.checkPermission(perm, context);
            }

            @Override
            public void checkExit(final int status) {
                super.checkExit(status);
                throw new ExitException(status);
            }
        });
        try {
            executable.run();
            fail("Expected System.exit(" + expectedStatus + ") to be called, but it wasn't called.");
        } catch (final ExitException e) {
            assertEquals(expectedStatus, e.status, "Wrong System.exit() status.");
        } finally {
            setSecurityManager(originalSecurityManager);
        }
    }

    public interface ThrowingExecutable<E extends Throwable> {
        void run() throws E;
    }

    private static class ExitException extends SecurityException {
        final int status;

        private ExitException(final int status) {
            this.status = status;
        }
    }
}

Vous pouvez utiliser la classe comme ceci:

    @Test
    void example() {
        assertExits(0, () -> System.exit(0)); // succeeds
        assertExits(1, () -> System.exit(1)); // succeeds
        assertExits(2, () -> System.exit(1)); // fails
    }

Le code peut facilement être porté sur JUnit 4, TestNG ou tout autre framework, si nécessaire. Le seul élément spécifique au framework échoue au test. Cela peut facilement être changé en quelque chose d'indépendant du framework (autre qu'un Junit 4 Rule

Il y a place à amélioration, par exemple, la surcharge assertExits()de messages personnalisables.

Permet Runtime.exec(String command)de démarrer la JVM dans un processus distinct.

Il y a un problème mineur avec la SecurityManagersolution. Certaines méthodes, telles que JFrame.exitOnClose, appellent également SecurityManager.checkExit. Dans mon application, je ne voulais pas que cet appel échoue, j'ai donc utilisé

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

Appeler System.exit () est une mauvaise pratique, sauf si cela se fait à l'intérieur d'un main (). Ces méthodes devraient lever une exception qui, finalement, est interceptée par votre main (), qui appelle ensuite System.exit avec le code approprié.