java - unitaria - ¿Por qué no se está ejecutando mi método @BeforeClass?

qué anotación indica que un método será una prueba

Question

Tengo el siguiente código:

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

Y varios otros métodos que son @Before, @After, @Test o @AfterClass métodos.

La prueba no falla al iniciarse, ya que parece que debería. ¿Puede alguien ayudarme por favor?

Tengo JUnit 4.5

El método está fallando en una llamada inmediata a setUp () que está anotado como @before. La definición de clase es:

public class myTests extends TestCase {

Answer 1

¡NO extienda TestCase Y use anotaciones al mismo tiempo!
Si necesita crear un conjunto de pruebas con anotaciones, use la anotación RunWith 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: nombres de clase con letra mayúscula)

Answer 2

Asegúrate de eso :

• Su clase de prueba no hereda de TestCase
• El método @BeforeClass es estático
• No tiene más de un método @BeforeClass en la jerarquía de clases de prueba (solo se ejecutará el método @BeforeClass más especializado)

Answer 3

Para que se ejecute la función anotada anteriormente, tuve que hacer lo siguiente: Si usa Maven, agregue 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 clase Junit Test no extienda la clase TestCase, ya que esto causará 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);
   }
}

Answer 4

el método debe ser estático y no invocar directamente al error (de lo contrario, los demás métodos no se ejecutarán).

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

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 sorprendentemente):

@BeforeClass
@Before
@Test
@After
@AfterClass