8 branches pour essayer avec des ressources - jacoco couverture possible?

Je peux couvrir tous les 8 branches, donc ma réponse est OUI. Regardez le code suivant, ce n'est qu'un rapide essai, mais ça marche (ou voir mon github: https://github.com/bachoreczm/basicjava et le "trywithresources' package, vous pourrez y trouver, comment essayez-avec-ressources, reportez-vous à 'ExplanationOfTryWithResources' classe):

import java.io.ByteArrayInputStream;
import java.io.IOException;
import org.junit.Test;
public class TestAutoClosable {
private boolean isIsNull = false;
private boolean logicThrowsEx = false;
private boolean closeThrowsEx = false;
private boolean getIsThrowsEx = false;
private void autoClose() throws Throwable {
try (AutoCloseable is = getIs()) {
doSomething();
} catch (Throwable t) {
System.err.println(t);
}
}
@Test
public void test() throws Throwable {
try {
getIsThrowsEx = true;
autoClose();
} catch (Throwable ex) {
getIsThrowsEx = false;
}
}
@Test
public void everythingOk() throws Throwable {
autoClose();
}
@Test
public void logicThrowsException() {
try {
logicThrowsEx = true;
everythingOk();
} catch (Throwable ex) {
logicThrowsEx = false;
}
}
@Test
public void isIsNull() throws Throwable {
isIsNull = true;
everythingOk();
isIsNull = false;
}
@Test
public void closeThrow() {
try {
closeThrowsEx = true;
logicThrowsEx = true;
everythingOk();
closeThrowsEx = false;
} catch (Throwable ex) {
}
}
@Test
public void test2() throws Throwable {
try {
isIsNull = true;
logicThrowsEx = true;
everythingOk();
} catch (Throwable ex) {
isIsNull = false;
logicThrowsEx = false;
}
}
private void doSomething() throws IOException {
if (logicThrowsEx) {
throw new IOException();
}
}
private AutoCloseable getIs() throws IOException {
if (getIsThrowsEx) {
throw new IOException();
}
if (closeThrowsEx) {
return new ByteArrayInputStream("".getBytes()) {
@Override
public void close() throws IOException {
throw new IOException();
}
};
}
if (!isIsNull) {
return new ByteArrayInputStream("".getBytes());
}
return null;
}
}

Quatre ans, mais quand même...

1. Heureux de chemin avec les non-null AutoCloseable
2. Heureux de chemin avec null AutoCloseable
3. Jette sur écrire
4. Jette sur près
5. Jette à écrire et à proximité
6. Jette dans la spécification de ressources (le avec partie, par exemple, appel du constructeur)
7. Jette dans try bloc mais AutoCloseable est null

Ci-dessus répertorie tous les 7 conditions de la raison pour les 8 branches est due à plusieurs reprises, fait état.

Toutes les branches peut être atteint, la try-with-resources est assez simple compilateur de sucre (au moins par rapport à switch-on-string) - si elles ne peuvent pas être atteint, il est, par définition, un bug du compilateur.

Seulement 6 les tests unitaires sont réellement nécessaires (dans l'exemple de code ci-dessous, throwsOnClose est @Ingored et de la direction générale de la couverture est 8/8.

Également noter que Throwable.addSuppressed(Throwable) ne peut pas supprimer lui-même, de sorte que le bytecode généré contient un supplément de garde (IF_ACMPEQ - référence de l'égalité) pour éviter cela). Heureusement, cette branche est couvert par la remise à l'écriture, jetez-sur-fermer et de le jeter à l'écriture-et-fermer les cas, comme le pseudo-code binaire variable fentes sont réutilisés par l'extérieur 2 de 3 gestionnaire d'exception régions.

C'est pas un problème avec Jacoco - en fait, l'exemple de code dans la question n ° 82 est incorrect, car il n'y a pas dupliqué null vérifie et il n'y a aucun bloc catch imbriqué environnant les fermer.

De test JUnit démonstration de 8 de 8 branches couvertes

import static org.hamcrest.Matchers.arrayContaining;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.sameInstance;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UncheckedIOException;
import org.junit.Ignore;
import org.junit.Test;
public class FullBranchCoverageOnTryWithResourcesTest {
private static class DummyOutputStream extends OutputStream {
private final IOException thrownOnWrite;
private final IOException thrownOnClose;
public DummyOutputStream(IOException thrownOnWrite, IOException thrownOnClose)
{
this.thrownOnWrite = thrownOnWrite;
this.thrownOnClose = thrownOnClose;
}
@Override
public void write(int b) throws IOException
{
if(thrownOnWrite != null) {
throw thrownOnWrite;
}
}
@Override
public void close() throws IOException
{
if(thrownOnClose != null) {
throw thrownOnClose;
}
}
}
private static class Subject {
private OutputStream closeable;
private IOException exception;
public Subject(OutputStream closeable)
{
this.closeable = closeable;
}
public Subject(IOException exception)
{
this.exception = exception;
}
public void scrutinize(String text)
{
try(OutputStream closeable = create()) {
process(closeable);
} catch(IOException e) {
throw new UncheckedIOException(e);
}
}
protected void process(OutputStream closeable) throws IOException
{
if(closeable != null) {
closeable.write(1);
}
}
protected OutputStream create() throws IOException
{
if(exception != null) {
throw exception;
}
return closeable;
}
}
private final IOException onWrite = new IOException("Two writes don't make a left");
private final IOException onClose = new IOException("Sorry Dave, we're open 24/7");
/**
* Covers one branch
*/
@Test
public void happyPath()
{
Subject subject = new Subject(new DummyOutputStream(null, null));
subject.scrutinize("text");
}
/**
* Covers one branch
*/
@Test
public void happyPathWithNullCloseable()
{
Subject subject = new Subject((OutputStream) null);
subject.scrutinize("text");
}
/**
* Covers one branch
*/
@Test
public void throwsOnCreateResource()
{
IOException chuck = new IOException("oom?");
Subject subject = new Subject(chuck);
try {
subject.scrutinize("text");
fail();
} catch(UncheckedIOException e) {
assertThat(e.getCause(), is(sameInstance(chuck)));
}
}
/**
* Covers three branches
*/
@Test
public void throwsOnWrite()
{
Subject subject = new Subject(new DummyOutputStream(onWrite, null));
try {
subject.scrutinize("text");
fail();
} catch(UncheckedIOException e) {
assertThat(e.getCause(), is(sameInstance(onWrite)));
}
}
/**
* Covers one branch - Not needed for coverage if you have the other tests
*/
@Ignore
@Test
public void throwsOnClose()
{
Subject subject = new Subject(new DummyOutputStream(null, onClose));
try {
subject.scrutinize("text");
fail();
} catch(UncheckedIOException e) {
assertThat(e.getCause(), is(sameInstance(onClose)));
}
}
/**
* Covers two branches
*/
@SuppressWarnings("unchecked")
@Test
public void throwsOnWriteAndClose()
{
Subject subject = new Subject(new DummyOutputStream(onWrite, onClose));
try {
subject.scrutinize("text");
fail();
} catch(UncheckedIOException e) {
assertThat(e.getCause(), is(sameInstance(onWrite)));
assertThat(e.getCause().getSuppressed(), is(arrayContaining(sameInstance(onClose))));
}
}
/**
* Covers three branches
*/
@Test
public void throwsInTryBlockButCloseableIsNull() throws Exception
{
IOException chucked = new IOException("ta-da");
Subject subject = new Subject((OutputStream) null) {
@Override
protected void process(OutputStream closeable) throws IOException
{
throw chucked;
}
};
try {
subject.scrutinize("text");
fail();
} catch(UncheckedIOException e) {
assertThat(e.getCause(), is(sameInstance(chucked)));
}
}
}

Mise en garde

Mais pas dans l'OP du code de l'échantillon, il existe un cas qui ne peuvent pas être testés autant que je sache.

Si vous passez la référence de la ressource comme un argument, puis en Java 7/8 vous devez avoir une variable locale à affecter à:

    void someMethod(AutoCloseable arg)
{
try(AutoCloseable pfft = arg) {
//...
}
}

Dans ce cas, le code généré sera toujours en gardant la référence à la ressource. Le syntatic sucre est mise à jour en Java 9, où la variable locale n'est plus nécessaire: try(arg){ /*...*/}

Supplémentaire Suggèrent d'utiliser la bibliothèque pour éviter les branches entièrement

Certes, certains de ces branches peuvent être radiés comme irréalistes, c'est à dire où le bloc try utilise le AutoCloseable sans nul de vérification ou d'où la référence de la ressource (with) ne peut pas être null.

Souvent votre application ne prend pas de soins où il a échoué à ouvrir le fichier, le modifier ou de le fermer - la granularité de l'échec n'est pas pertinent (sauf si l'application est en particulier les fichiers, par exemple, l'explorateur de fichier ou traitement de texte).

En outre, dans le cas des OP de code, afin de tester la valeur null fermer le chemin d'accès que vous auriez à refactoriser le bloc try dans une méthode protégée, la sous-classe et de fournir un NOOP mise en œuvre, tout cela à obtenir une couverture sur les branches qui ne sera jamais pris à l'état sauvage.

J'ai écrit un petit Java 8 bibliothèque io.earcam.rien d'exceptionnel (en Maven Central) qui traite de la plupart vérifié exception standard.

Pertinentes à la question: il fournit une bande de zéro-branche, one-liners pour AutoCloseables, la conversion checked exceptions à décochée.

Exemple: Port Libre Finder

int port = Closing.closeAfterApplying(ServerSocket::new, 0, ServerSocket::getLocalPort);

j'ai eu un problème similaire avec quelque chose comme ceci:

try {
...
} finally {
if (a && b) {
...
}
}

il se plaint que 2 des 8 branches n'étaient pas couverts. fini par faire ceci:

try {
...
} finally {
ab(a,b);
}
void ab(a, b) {
if (a && b) {
...
}
}

pas d'autres modifications, et j'ai maintenant atteint 100%....