BugRaptor’s always ensure that the script/code written for JUnit framework should have better readability and Structures. To simplify this concern, the testers use JUnit annotations to improve the quality of code.

1. How To Use Ignore Annotation In
JUnit?

2. Introduction
JUnit is an open source framework for Java programming language which
is used for writing and running tests. This practice helps developers to
discover failures in their logic behind the code and improve the quality of
their code. Also, JUnit testing can be used in order to guarantee that, the
code will work as expected in case of future changes. We can integrate
JUnit Framework with Eclipse, Ant and Maven.

3. Do you know about JUnit annotation
and theirs use?
Annotation is a predefined logic that is added java source code.
Classes, methods, variables, parameters and packages may be
annotated. JUnit uses annotations and works according to the
annotation’s predefined logic.
JUnit framework works on following these annotations which are
named as below:
1. @BeforeClass
2. @AfterClass
3. @Before
4. @After
5. @Test
6. @Ignore
7. @RunWith

4. 1. @BeforeClass: This annotation will run once before any of the test
methods in the class. This annotation neither provides any parameter
nor returns any parameter. The @BeforeClass methods of
superclasses will be run before those the current class.
2. @AfterClass: This annotation will run once after all the tests in the
class have been run. All @AfterClass methods are guaranteed to run
even if a BeforeClass method throws an exception. The @AfterClass
methods declared in superclasses will be run after those of the
current class. This annotation neither provides any parameter nor
returns any parameter.
3. @Before: This annotation will run before each @Test. The @Before
methods of super classes will be run before those of the current
class. This annotation neither provides any parameter nor returns
any parameter.

5. 4. @After: This annotation will run after each @Test. The @After
methods declared in superclasses will be run after those of the
current class. This annotation neither provides any parameter nor
returns any parameter.
5. @Test: The Test annotation tells JUnit that this is the test that needs
to be executed. Any exceptions thrown by the @Test will be
reported by JUnit as a failure. If no exceptions are thrown, the test is
assumed to have succeeded. This annotation uses optional
parameters as expected, timeout and so on.
6. @Ignore: Sometimes you want to temporarily disable a test or a
group of tests. Methods annotated with Test that are also annotated
with @Ignore will not be executed as tests.
7. @RunWith: When a class is annotated with @RunWith or extends a
class annotated with @RunWith, JUnit will invoke the class it
references to run the tests in that class instead of the runner built
into JUnit.

6. Have you ever faced problem with
@Ignore annotation?
If you are not using JUnit and you want to temporarily disable a particular
@Test which is partially implemented OR don’t want that @Test to fail
while running a test methods, then you will be either comment that
particular @Test or you will delete the @Test and the test runner class
also not includes such @Test in report.
Solution:
JUnit provides you an annotation to overcome this problem named as
@Ignore. The @Ignore annotation can be used when you want
temporarily disable the execution of a particular @test. Every method
that is associated with @Ignore won’t be executed. Test runner class also
includes such @Test in report.
@Ignore annotation can be used in two ways:
1. To ignore particular @Test
2. To ignore a Class

7. Use @Ignore annotation with test
method
A class could have numbers of test methods and some of them might not
be required in execution due to some reasons like partial implemented
and so on, then we use @Ignore annotation to skip them.
Below is the example that a class has two @Test methods, one is with
@Ignore annotation and second @Test is without @Ignore annotation.

8. After execution the JUnit result will look like this as displaying in
below screenshot:

9. Use @Ignore annotation with Class
@Ignore can also be used with Class to skip the whole class means all the
@Test methods inside a class will be skipped.
Below is the example, how to ignore all the tests in class:

10. After execution the JUnit result will look like this as displaying in below
screenshot:

11. We can also pass string argument in @Ignore annotation. This is an
optional parameter, using this string parameter you can show the reason
why you have ignored the @Test or Class.
Below is the example, how to pass string parameter in @Ignore
annotation:

12. But output will be same as above, the parameter string used in
@Ignore annotation is not printed in JUnit output.