[java] 8 sucursales para probar con recursos: ¿es posible la cobertura de jacoco?



Answers

Puedo cubrir las 8 ramas, por lo que mi respuesta es SÍ. Mire el siguiente código, este es solo un intento rápido, pero funciona (o vea mi github: https://github.com/bachoreczm/basicjava y el paquete 'trywithresources', allí puede encontrar, cómo probar-con- los recursos funcionan, consulte la clase 'ExplanationOfTryWithResources'):

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

Tengo un código que usa try with resources y en jacoco está apareciendo medio cubierto. Todas las líneas de código fuente son verdes, pero obtengo un pequeño símbolo amarillo que me dice que solo 4 de 8 ramas están cubiertas.

Tengo problemas para averiguar qué son todas las ramas y cómo escribir el código que las cubre. Tres posibles lugares lanzan PipelineException . Estos son createStageList() , processItem() y el implied close()

  1. No lanzando ninguna excepción,
  2. lanzando una excepción desde createStageList()
  3. lanzando una excepción desde processItem()
  4. lanzando una excepción desde close()
  5. lanzando una excepción desde processItem() y close()

No puedo pensar en ningún otro caso, sin embargo, solo tengo 4 de 8 cubiertos.

¿Puede alguien explicarme por qué son 4 de 8 y de todos modos hay disponible para golpear las 8 ramas? No soy experto en descifrar / leer / interpretar el código de bytes, pero tal vez tú ... :) Ya he visto https://github.com/jacoco/jacoco/issues/82 , pero ni el problema ni el problema hace referencia a la ayuda (aparte de señalar que esto se debe a bloques generados por el compilador)

Hmm, justo cuando termino de escribir esto, pensé en qué caso (s) podría no estar probado por lo que mencioné anteriormente ... Publicaré una respuesta si lo hice bien. Estoy seguro de que esta pregunta y su respuesta ayudarán a alguien en cualquier caso.

EDITAR: No, no lo encontré. Lanzando RuntimeExceptions (no manejado por el bloque catch) no cubría más ramas




tuve un problema similar con algo como esto:

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

se quejó de que 2 de 8 ramas no estaban cubiertas. terminó haciendo esto:

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

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

no hay otros cambios y ahora llegué al 100% ...




Cuatro años, pero aún ...

  1. Feliz camino con AutoCloseable no nulo
  2. Feliz camino con nulo AutoCloseable
  3. Lanza en escribir
  4. Lanza cerca
  5. Lanza sobre escribir y cerrar
  6. Lanza en especificación de recursos (la parte con , por ejemplo, llamada de constructor)
  7. Lanza en bloque try pero AutoCloseable es nulo

Arriba enumera las 7 condiciones: la razón de las 8 ramas se debe a la repetición de las condiciones.

Se puede acceder a todas las sucursales, try-with-resources es bastante simple compilador de azúcar (al menos en comparación con switch-on-string ) - si no pueden ser alcanzados, entonces es por definición un error de compilación.

Solo se requieren 6 pruebas unitarias (en el siguiente código de ejemplo, throwsOnClose is @Ingore d y la cobertura de sucursales es 8/8.

También tenga en cuenta que Throwable.addSuppressed(Throwable) no puede suprimirse, por lo que el bytecode generado contiene una protección adicional (IF_ACMPEQ - igualdad de referencia) para evitar esto). Afortunadamente, esta rama está cubierta por los casos throw-on-write, throw-on-close y throw-on-write-and-close, ya que las ranuras variables bytecode son reutilizadas por las regiones externas 2 o 3 del manejador de excepciones.

Esto no es un problema con Jacoco; de hecho, el código de ejemplo en el https://github.com/jacoco/jacoco/issues/82 vinculado https://github.com/jacoco/jacoco/issues/82 es incorrecto, ya que no hay controles nulos duplicados y no hay un bloque de captura anidado que rodee el cierre.

Prueba JUnit que demuestra 8 de 8 ramas cubiertas

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

    }
}

Advertencia

Aunque no está en el código de muestra de OP, hay un caso que no se puede probar AFAIK.

Si pasa la referencia de recurso como argumento, entonces en Java 7/8 debe tener una variable local para asignar a:

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

En este caso, el código generado seguirá protegiendo la referencia del recurso. El azúcar sintáctico se actualiza en Java 9 , donde la variable local ya no es necesaria: try(arg){ /*...*/ }

Complementario: sugiera el uso de la biblioteca para evitar las ramas por completo

Hay que admitir que algunas de estas ramas se pueden descartar como no realistas, es decir, donde el bloque try usa AutoCloseable sin verificación nula o donde la referencia del recurso ( with ) no puede ser nula.

A menudo, a su aplicación no le importa dónde falló: para abrir el archivo, escribir en él o cerrarlo, la granularidad de la falla es irrelevante (a menos que la aplicación esté específicamente relacionada con los archivos, por ejemplo, el buscador de archivos o el procesador de textos).

Además, en el código de OP, para probar el camino de cierre nulo, tendrías que refactorizar el bloque de prueba en un método protegido, subclase y proporcionar una implementación de NOOP, todo esto solo obtendría cobertura en ramas que nunca se tomarán en la naturaleza. .

Escribí una pequeña biblioteca de Java 8 io.earcam.unexceptional (en Maven Central ) que se ocupa de la mayoría de las repeticiones repetidas .

Pertinente a esta pregunta: proporciona un grupo de ramas cero y de una sola línea para AutoCloseable , convirtiendo las excepciones marcadas en desmarcadas.

Ejemplo: Buscador de puertos gratis

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



Links