JUnit test pour le Système.out.println()

Je sais que c'est un vieux thread, mais il y a une belle bibliothèque pour ce faire:

Système De Règles

Exemple de la doc:

public void MyTest {
    @Rule
    public final SystemOutRule systemOutRule = new SystemOutRule().enableLog();

    @Test
    public void overrideProperty() {
        System.out.print("hello world");
        assertEquals("hello world", systemOutRule.getLog());
    }
}

Il vous permettra également de piège System.exit(-1) et d'autres choses qu'un outil de ligne de commande devrait être testée pour.

Au lieu de rediriger System.out, je refactoriser la classe qui l'utilise System.out.println() par le passage d'un PrintStream tant que collaborateur, puis à l'aide de System.out de la production et une Test Spy dans le test. C'est, utiliser l'Injection de Dépendance pour éliminer l'utilisation directe du flux de sortie standard.

Dans La Production

ConsoleWriter writer = new ConsoleWriter(System.out));

Dans le Test

ByteArrayOutputStream outSpy = new ByteArrayOutputStream();
ConsoleWriter writer = new ConsoleWriter(new PrintStream(outSpy));
writer.printSomething();
assertThat(outSpy.toString(), is("expected output"));

Discussion

De cette façon, la classe sous test devient testable par un simple, sans avoir besoin de indirect de la redirection de la sortie standard ou obscur interception avec un système de règle.

@dfa réponse est grande, donc je l'ai pris un peu plus loin pour le rendre possible de faire le test des blocs de sortie.

J'ai d'abord créé TestHelper avec une méthode captureOutput qui accepte les annoymous classe CaptureTest. Le captureOutput méthode effectue le travail de définition et de démolir les flux de sortie. Lors de la mise en œuvre de CaptureOutput's test méthode est appelée, elle a accès à la sortie de générer pour le bloc d'essai.

Source pour TestHelper:

public class TestHelper {

    public static void captureOutput( CaptureTest test ) throws Exception {
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        ByteArrayOutputStream errContent = new ByteArrayOutputStream();

        System.setOut(new PrintStream(outContent));
        System.setErr(new PrintStream(errContent));

        test.test( outContent, errContent );

        System.setOut(new PrintStream(new FileOutputStream(FileDescriptor.out)));
        System.setErr(new PrintStream(new FileOutputStream(FileDescriptor.out)));

    }
}

abstract class CaptureTest {
    public abstract void test( ByteArrayOutputStream outContent, ByteArrayOutputStream errContent ) throws Exception;
}

Noter que TestHelper et CaptureTest sont définies dans le même fichier.

Puis dans votre test, vous pouvez importer de la statique captureOutput. Voici un exemple d'utilisation de JUnit:

//imports for junit
import static package.to.TestHelper.*;

public class SimpleTest {

    @Test
    public void testOutput() throws Exception {

        captureOutput( new CaptureTest() {
            @Override
            public void test(ByteArrayOutputStream outContent, ByteArrayOutputStream errContent) throws Exception {

                //code that writes to System.out

                assertEquals( "the expected output\n", outContent.toString() );
            }
        });
}

Basé sur @dfa réponse et une autre réponse qui montre comment le Système de test.dans, je voudrais partager ma solution pour donner une entrée à un programme et de tester sa sortie.

Comme une référence, je utiliser JUnit 4.12.

Disons que nous avons de ce programme qui reprend simplement l'entrée à la sortie:

import java.util.Scanner;

public class SimpleProgram {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print(scanner.next());
        scanner.close();
    }
}

Pour le tester, nous pouvons utiliser la classe suivante:

import static org.junit.Assert.*;

import java.io.*;

import org.junit.*;

public class SimpleProgramTest {
    private final InputStream systemIn = System.in;
    private final PrintStream systemOut = System.out;

    private ByteArrayInputStream testIn;
    private ByteArrayOutputStream testOut;

    @Before
    public void setUpOutput() {
        testOut = new ByteArrayOutputStream();
        System.setOut(new PrintStream(testOut));
    }

    private void provideInput(String data) {
        testIn = new ByteArrayInputStream(data.getBytes());
        System.setIn(testIn);
    }

    private String getOutput() {
        return testOut.toString();
    }

    @After
    public void restoreSystemInputOutput() {
        System.setIn(systemIn);
        System.setOut(systemOut);
    }

    @Test
    public void testCase1() {
        final String testString = "Hello!";
        provideInput(testString);

        SimpleProgram.main(new String[0]);

        assertEquals(testString, getOutput());
    }
}

Je ne vais pas expliquer en grande partie, parce que je crois que le code est lisible et j'ai cité mes sources.

Quand JUnit s'exécute testCase1(), il va appeler les méthodes d'assistance dans l'ordre où ils apparaissent:

1. setUpOutput(), en raison de la @Before annotation
2. provideInput(String data), appelé à partir de testCase1()
3. getOutput(), appelé à partir de testCase1()
4. restoreSystemInputOutput(), en raison de la @After annotation

Je n'ai pas fait de test System.err parce que je n'en avais pas besoin, mais il devrait être facile à mettre en œuvre, similaire au test de System.out.

Plein JUnit 5 par exemple pour tester System.out (remplacer lors de la partie):

package learning;

import static org.assertj.core.api.BDDAssertions.then;

import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class SystemOutLT {

    private PrintStream originalSystemOut;
    private ByteArrayOutputStream systemOutContent;

    @BeforeEach
    void redirectSystemOutStream() {

        originalSystemOut = System.out;

        //given
        systemOutContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(systemOutContent));
    }

    @AfterEach
    void restoreSystemOutStream() {
        System.setOut(originalSystemOut);
    }

    @Test
    void shouldPrintToSystemOut() {

        //when
        System.out.println("example");

        then(systemOutContent.toString()).containsIgnoringCase("example");
    }
}

pour

@Test
void it_prints_out() {

    PrintStream save_out=System.out;final ByteArrayOutputStream out = new ByteArrayOutputStream();System.setOut(new PrintStream(out));

    System.out.println("Hello World!");
    assertEquals("Hello World!\r\n", out.toString());

    System.setOut(save_out);
}

pour tre

@Test
void it_prints_err() {

    PrintStream save_err=System.err;final ByteArrayOutputStream err= new ByteArrayOutputStream();System.setErr(new PrintStream(err));

    System.err.println("Hello World!");
    assertEquals("Hello World!\r\n", err.toString());

    System.setErr(save_err);
}