Java: Cara menguji metode yang memanggil System.exit ()?

Saya punya beberapa metode yang harus memanggil System.exit()input tertentu. Sayangnya, menguji kasus-kasus ini menyebabkan JUnit berakhir! Menempatkan panggilan metode di Thread baru tampaknya tidak membantu, karena System.exit()mengakhiri JVM, bukan hanya utas saat ini. Apakah ada pola umum untuk menangani ini? Sebagai contoh, dapatkah saya menggantikan rintisan System.exit()?

[EDIT] Kelas yang dimaksud sebenarnya adalah alat baris perintah yang saya coba uji di dalam JUnit. Mungkin JUnit bukan alat yang tepat untuk pekerjaan itu? Saran untuk alat pengujian regresi komplementer dipersilahkan (lebih disukai sesuatu yang terintegrasi dengan baik dengan JUnit dan EclEmma).

Memang, Derkeiler.com menyarankan:

• Mengapa System.exit()?

Alih-alih mengakhiri dengan System.exit (whateverValue), mengapa tidak membuang pengecualian yang tidak dicentang? Dalam penggunaan normal, itu akan melayang keluar sampai ke penangkap terakhir JVM dan menutup skrip Anda (kecuali Anda memutuskan untuk menangkapnya di suatu tempat di sepanjang jalan, yang mungkin berguna suatu hari nanti).

Dalam skenario JUnit itu akan ditangkap oleh kerangka kerja JUnit, yang akan melaporkan bahwa tes ini-dan-itu gagal dan bergerak dengan lancar ke yang berikutnya.

• Cegah System.exit()untuk benar-benar keluar dari JVM:

Coba ubah TestCase untuk dijalankan dengan manajer keamanan yang mencegah pemanggilan System.exit, lalu tangkap 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);
        }
    }
}

Pembaruan Desember 2012:

Akan mengusulkan dalam komentar menggunakan Aturan Sistem , kumpulan aturan JUnit (4.9+) untuk menguji kode yang digunakan java.lang.System.
Ini awalnya disebutkan oleh Stefan Birkner dalam jawabannya pada Desember 2011.

System.exit(…)

Gunakan ExpectedSystemExitaturan untuk memverifikasi yang System.exit(…)dipanggil.
Anda dapat memverifikasi status keluar juga.

Misalnya:

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

Pustaka Aturan Sistem memiliki aturan JUnit yang disebut ExpectedSystemExit. Dengan aturan ini Anda dapat menguji kode, yang memanggil 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);
    }
}

Pengungkapan penuh: Saya penulis perpustakaan itu.

Bagaimana dengan menyuntikkan "ExitManager" ke dalam Metode ini:

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

Kode produksi menggunakan ExitManagerImpl dan kode tes menggunakan ExitManagerMock dan dapat memeriksa apakah exit () dipanggil dan dengan kode keluar mana.

Anda sebenarnya dapat mengejek atau mematikan System.exitmetodenya, dalam tes JUnit.

Misalnya, menggunakan JMockit Anda dapat menulis (ada juga cara lain):

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

EDIT: Tes alternatif (menggunakan JMockit API terbaru) yang tidak memungkinkan kode untuk dijalankan setelah panggilan ke 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)");
}

Salah satu trik yang kami gunakan dalam basis kode kami adalah membuat panggilan ke System.exit () dienkapsulasi dalam imp Runnable, yang metode yang dimaksud digunakan secara default. Untuk pengujian unit, kami menetapkan Runnable tiruan yang berbeda. Sesuatu seperti ini:

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

... dan metode uji JUnit ...

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

Buat kelas mock-mampu yang membungkus System.exit ()

Saya setuju dengan EricSchaefer . Tetapi jika Anda menggunakan kerangka kerja mocking yang baik seperti Mockito kelas beton sederhana sudah cukup, tidak perlu untuk antarmuka dan dua implementasi.

Menghentikan eksekusi tes pada System.exit ()

Masalah:

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

Mocked Sytem.exit()tidak akan menghentikan eksekusi. Ini buruk jika Anda ingin menguji yang thing2tidak dieksekusi.

Larutan:

Anda harus memperbaiki kode ini seperti yang disarankan oleh martin :

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

Dan lakukan System.exit(status)dalam fungsi panggilan. Ini memaksa Anda untuk memiliki semua milik Anda System.exit()di satu tempat di atau dekat main(). Ini lebih bersih daripada memanggil System.exit()jauh ke dalam logika Anda.

Kode

Pembungkus:

public class SystemExit {

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

Utama:

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

Uji:

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

Saya suka beberapa jawaban yang sudah diberikan tetapi saya ingin menunjukkan teknik berbeda yang sering berguna ketika mendapatkan kode lama yang diuji. Kode yang diberikan seperti:

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

Anda dapat melakukan refactoring yang aman untuk membuat metode yang membungkus panggilan System.exit:

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

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

Kemudian Anda dapat membuat palsu untuk pengujian Anda yang menimpa keluar:

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

Ini adalah teknik generik untuk menggantikan perilaku untuk kasus uji, dan saya menggunakannya sepanjang waktu ketika refactoring kode lama. Biasanya tidak di mana saya akan meninggalkan sesuatu, tetapi langkah menengah untuk mendapatkan kode yang ada di bawah tes.

Pandangan cepat pada api, menunjukkan bahwa System.exit dapat melempar pengecualian esp. jika seorang manajer keamanan melarang penutupan vm. Mungkin solusinya adalah menginstal manajer seperti itu.

Anda dapat menggunakan java SecurityManager untuk mencegah utas saat ini dari mematikan Java VM. Kode berikut harus melakukan apa yang Anda inginkan:

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

Agar jawaban VonC berjalan pada JUnit 4, saya telah memodifikasi kodenya sebagai berikut

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

Anda dapat menguji System.exit (..) dengan mengganti instance Runtime. Misalnya dengan 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);
    }
}

Ada lingkungan di mana kode keluar yang dikembalikan digunakan oleh program panggilan (seperti ERRORLEVEL di MS Batch). Kami memiliki tes di sekitar metode utama yang melakukan ini dalam kode kami, dan pendekatan kami telah menggunakan penggantian SecurityManager yang sama seperti yang digunakan dalam tes lain di sini.

Tadi malam saya mengumpulkan JAR kecil menggunakan penjelasan Junit @Rule untuk menyembunyikan kode manajer keamanan, serta menambahkan harapan berdasarkan kode pengembalian yang diharapkan. http://code.google.com/p/junitsystemrules/

Sebagian besar solusi akan melakukannya

• hentikan tes (metode, bukan seluruh proses) saat System.exit()ini disebut
• abaikan yang sudah diinstal SecurityManager
• Terkadang cukup spesifik untuk kerangka uji
• batasi untuk digunakan maksimal satu kali per test case

Dengan demikian, sebagian besar solusi tidak cocok untuk situasi di mana:

• Verifikasi efek samping harus dilakukan setelah panggilan ke System.exit()
• Manajer keamanan yang ada adalah bagian dari pengujian.
• Kerangka uji yang berbeda digunakan.
• Anda ingin memiliki beberapa verifikasi dalam satu test case. Ini mungkin sangat tidak dianjurkan, tetapi bisa sangat nyaman di kali, terutama dalam kombinasi dengan assertAll(), misalnya.

Saya tidak senang dengan pembatasan yang diberlakukan oleh solusi yang ada yang disajikan dalam jawaban lain, dan dengan demikian muncul dengan sesuatu sendiri.

Kelas berikut menyediakan metode assertExits(int expectedStatus, Executable executable)yang menyatakan bahwa System.exit()dipanggil dengan statusnilai yang ditentukan , dan tes dapat dilanjutkan setelahnya. Ini bekerja dengan cara yang sama seperti JUnit 5assertThrows . Itu juga menghormati manajer keamanan yang ada.

Ada satu masalah yang tersisa: Ketika kode yang diuji menginstal manajer keamanan baru yang sepenuhnya menggantikan manajer keamanan yang ditetapkan oleh tes. Semua SecurityManagersolusi berbasis lainnya yang saya kenal menderita masalah yang sama.

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

Anda dapat menggunakan kelas seperti ini:

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

Kode dapat dengan mudah porting ke JUnit 4, TestNG, atau kerangka kerja lainnya, jika perlu. Satu-satunya elemen kerangka spesifik gagal tes. Ini dapat dengan mudah diubah menjadi sesuatu yang independen kerangka kerja (selain Junit 4 Rule

Ada ruang untuk perbaikan, misalnya, kelebihan muatan assertExits()dengan pesan yang dapat disesuaikan.

Gunakan Runtime.exec(String command)untuk memulai JVM dalam proses terpisah.

Ada masalah kecil dengan SecurityManagersolusinya. Beberapa metode, seperti JFrame.exitOnClose, juga meneleponSecurityManager.checkExit . Dalam aplikasi saya, saya tidak ingin panggilan itu gagal, jadi saya gunakan

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

Memanggil System.exit () adalah praktik yang buruk, kecuali itu dilakukan di dalam main (). Metode-metode ini harus membuang pengecualian yang, pada akhirnya, ditangkap oleh main Anda (), yang kemudian memanggil System.exit dengan kode yang sesuai.