TestNg's @BeforeTest on base class only happening once per fixture

I'm trying to use @BeforeTest to get code to ... run once before every test.

This is my code:

public class TestBase {
    @BeforeTest
    public void before() {
        System.out.println("BeforeTest开发者_开发知识库");
    }
}

public class TestClass extends TestBase{
    @Test
    public void test1(){}

    @Test
    public void test2(){}
}

"BeforeTest" is only printed once, not twice. What am I doing wrong?

Use @BeforeMethod, not @BeforeTest.

The meaning of @BeforeTest is explained in the documentation.

"BeforeTest" is only printed once, not twice. What am I doing wrong?

***Sorry. I haven't noticed that you is written @BeforeTest , but in your example @BeforeTest almost equals @BeforeClass , and better to use @BeforeClass , when you haven't anymore test classes.

@BeforeClass" should be declared in same class that your tests methods, not differently!

//Example

package test;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

public class Tests {
private String bClass;
private String bMethod1;
private String bMethod2;

@BeforeClass
public void beforeClass() {
    bClass = "BeforeClass was executed once for this class";
}

@BeforeMethod
public void beforeMetodTest1() {
    bMethod1 = "It's before method for test1";
}

@Test
public void test1() {
    System.out.println(bClass);
    System.out.println(bMethod1);
}

@BeforeMethod
public void beforeMethodTest2() {
    bMethod2 = "It's before method for test2";
}

@Test
public void test2() {
    System.out.println(bClass);
    System.out.println(bMethod2);
}
}

@BeforeClass will executed once, before your all tests methods in this class. @BeforeMethod will executed before test method, before which it is written.

@BeforeClass may be only one in test class, in difference @BeforeMethod!(If it is some @BeforeClass, they are carried out by turns, but it not a correct composition of the test)

P.S. Sorry for my English :)

According to documentation, a method annotated with @BeforeTest is run before any @Test method belonging to the classes inside the tag is run.

From my experience:

• Each @BeforeTest method is run only once
• If you have several @BeforeTest methods, the order of their execution depends on the order of the class containing those @BeforeTest method.

You could test this by setting up a simple example.

If you use @beforeTest, that method will be run once in the beginning of every <test> (we specify in the test suit xml file) if that test contains that class

All the @befortests within all the classes within a <test> will be executed at the beggining of that test

Official Documentations are so unclear and mostly ambiguous. This is why many don't like to read it. Not to mention no real-life examples shown.

If you are trying to get code to run once before every test, then you are looking for @BeforeMethod, not @BeforeTest. Because each of your tests independently considered methods.

@BeforeMethod runs before each method. I see you have two methods with the names test1() and test2(). Expect BeforeMethod to run before each of them.

@BeforeTest runs only once before ALL of your tests (test-methods). In Selenium, WebDriver is called once, this is better practice for testing. @BeforeMethod will invoke WebDriver before each test, this is not good practice, especially when you have regression tests with hundreds of them to run.

For example, if you run this code (these are separate classes, not inner to each other, only showing for demonstration purposes here):

public class TestClass extends Base {

    @Test
    public void test1() {
        System.out.println("Running Test 1");
    }

    @Test
    public void test2() {
        System.out.println("Running Test 2");
    }

}

public class Base {

    @BeforeTest
    public void beforeTest() {
        System.out.println("Before Test");
    }

    @AfterTest
    public void afterTest() {
        System.out.println("After Test");
    }

    @BeforeMethod
    public void beforeMethod() {
        System.out.println("Before Method");
    }

    @AfterMethod
    public void afterMethod() {
        System.out.println("After Method");
    }

}

And you will get this as an output:

Before Test
Before Method
Running Test 1
After Method
Before Method
Running Test 2
After Method
After Test

As you can see BeforeMethods run before each test while BeforeTest and AfterTest run only once before and after completing ALL tests.

Hope this clarified the difference for you.