Tengo el siguiente código:

    @BeforeClass
    public static void setUpOnce() throws InterruptedException {
        fail("LOL");
    }

Y varios otros métodos que son de @Antes, @Después, @Test o @AfterClass métodos.

La prueba no falla en el arranque, como parece que debe. Alguien me puede ayudar por favor?

He JUnit 4.5

El método está fallando en una llamada inmediata a setUp (), que es anotado como @antes.
La clase def :

public class myTests extends TestCase {
  • Usted puede confirmar lo de la versión de junit que tiene en su classpath?
  • He JUnit 4.5 en el classpath

4 Comentarios

  1. 64

    NO extender la Prueba Y el uso de anotaciones en el mismo tiempo!

    Si usted necesita para crear un conjunto de pruebas con anotaciones, el uso de la RunWith anotación como:

    @RunWith(Suite.class)
    @Suite.SuiteClasses({ MyTests.class, OtherTest.class })
    public class AllTests {
        //empty
    }
    
    
    public class MyTests {  //no extends here
        @BeforeClass
        public static void setUpOnce() throws InterruptedException {
            ...
        @Test
        ...

    (por convención: la clase de los nombres con mayúscula)

    • Sí, esta es una mejor opción. No sabía acerca de estos @Suite y @RunWith anotaciones. +1 y gracias por tus entradas.
    • gracias. Tuve un tiempo difícil para encontrar que la semana pasada.. que tipo de justo a tiempo
    • Muchas gracias Carlos, funciona bien ahora. También gracias por toda su ayuda Vinagre.
    • sólo tenía el mismo problema ya esta resuelto para mí. Gracias!
    • estoy ampliación de una clase que tiene los métodos como logins y sessions y necesito ejecutar @BeforeClass anotado método también. Es eso posible?
    • lo siento, este debe ser formulado como una pregunta, no como un comentario.
    • 4 años tarde, pero para el resto de los lectores, sí que es posible.

  2. 16

    el método debe ser estática y no llamar directamente a fallar (de lo contrario los otros métodos no se ejecuta).

    La clase siguiente muestra todos los estándar de JUnit 4 tipos de métodos:

    public class Sample {
    
        @BeforeClass
        public static void beforeClass() {
            System.out.println("@BeforeClass");
        }
    
        @Before
        public void before() {
            System.out.println("@Before");
        }
    
        @Test
        public void test() {
            System.out.println("@Test");
        }
    
        @After
        public void after() {
            System.out.println("@After");
        }
    
        @AfterClass
        public static void afterClass() {
            System.out.println("@AfterClass");
        }
    
    }

    y la salida es (no es de extrañar):

    @BeforeClass
    @Before
    @Test
    @After
    @AfterClass
    • Estás en lo correcto, gracias, pero no empezar a trabajar una vez que he cambiado a la electricidad estática.
    • Nos muestran la definición de la clase. Podría ser el caso de que su clase es una subclase de someother, y que clase de padre puede tener algún método anotado con @BeforeClass, y que el método de la clase padre es acabar con algunos errores y causando la interrupción.
    • De lo contrario, intente agregar una normal método de prueba.
    • El método está fallando en una llamada inmediata a setUp (), que es anotado como @antes. La clase def es : public class myTests extends TestCase {
    • Están teniendo algún @métodos de Prueba?
    • Sí, como estados de cuestión.
    • A mí me funciona, gracias.

  3. 2

    Asegúrese de que :

    • Tu clase de prueba no se hereda de la Prueba
    • La @BeforeClass método es estático
    • Usted no tiene más de un @BeforeClass método de prueba de la jerarquía de clases (sólo los más especializados @BeforeClass método será ejecutado)
    • Ejecución de jUnit 4.11 permite que más de un @BeforeClass , uno en su clase y uno en un super clase, y se llama.
  4. 0

    A fin de que la antes comentada función se ejecute , tuve que hacer lo siguiente:
    Si se utiliza Maven , agregar una dependencia a Junit 4.11+:

          <properties>
                  <version.java>1.7</version.java>
                  <version.log4j>1.2.13</version.log4j>
                  <version.mockito>1.9.0</version.mockito>
                  <version.power-mockito>1.4.12</version.power-mockito>
                   <version.junit>4.11</version.junit>   
                  <version.power-mockito>1.4.12</version.power-mockito>
          </properties>           

    y la dependencia:

          <dependencies>
            <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <version>${version.junit}</version>
             <scope>test</scope>
           </dependency>    
            .
            .
            .
          </dependencies>

    Asegúrese de que su Prueba de Junit clase no es el de la ampliación de La Prueba de clase, ya que esto hará que la superposición con la versión anterior:

    public class TuxedoExceptionMapperTest{
       protected TuxedoExceptionMapper subject;
    
       @Before
       public void before() throws Exception {
         subject = TuxedoExceptionMapper.getInstance();
          System.out.println("Start");
          MockitoAnnotations.initMocks(this);
       }
    }

Dejar respuesta

Please enter your comment!
Please enter your name here