@BeforeClass и наследование - порядок выполнения

Не помещайте @BeforeClass в класс abstract. Вызовите его из каждого подкласса.

abstract class A {
    void doInitialization() {}
}

class B extends A {
    @BeforeClass
    void doSpecificInitialization() {
        super.doInitialization();
    }

    @Test
    void doTests() {}
}

Похоже, в TestNG есть @BeforeClass(dependsOnMethods={"doInitialization"}) - дайте ему пытаться.

edit: Ответ ниже относится к JUnit, но я все равно оставлю его здесь, потому что он может быть полезен.

Согласно JUnit api: "Методы суперклассов @BeforeClass будет запущен перед текущим классом ".

Я протестировал это, и, похоже, у меня это работает.

Однако, как упоминает @Odys ниже, для JUnit вам необходимо иметь два метода с разными именами, хотя в противном случае будет запущен только метод подкласса, потому что родительский элемент будет затенен.

Я добавил public в абстрактный класс, а TestNG (6.0.1) выполнил doInitialization () до doTests. TestNG не выполняет doInitialization(), если я удалю public из класса A.

public abstract class A {
 @BeforeClass
 doInitialization() {...}
}

class B extends A {    
 @Test
 doTests() {...}
}

Я только что попробовал ваш пример с 5.11, и сначала я вызываю @BeforeClass базового класса.

Вы можете опубликовать свой файл testng.xml? Возможно, вы указываете там как A, так и B, а необходим только B.

Не стесняйтесь следить за списком рассылки testng-users, и мы сможем более внимательно изучить вашу проблему.

- Седрик

Я только что прошел через это и нашел еще один способ добиться этого. Просто используйте alwaysRun в @BeforeClass или @BeforeMethod в абстрактном классе, работает, как и следовало ожидать.

public class AbstractTestClass {
    @BeforeClass(alwaysRun = true)
    public void generalBeforeClass() {
        // do stuff
        specificBeforeClass();
    }
}

Для JUnit: как упомянул @fortega: Согласно JUnit api: «Методы суперклассов @BeforeClass будут выполняться раньше, чем методы текущего класса».

Но будьте осторожны, не называйте оба метода одинаковыми именами. Поскольку в этом случае родительский метод будет скрыт дочерним родителем. Источник.

Когда я бегу из: JUnitCore.runClasses (TestClass.class); он будет правильно выполнять родительский элемент до дочернего (вам не нужен super.SetUpBeforeClass ();) Если вы запустите его из Eclipse: по какой-то причине он не может запустить базовый класс. Решение: явным образом вызовите базовый класс: (BaseTest.setUpBeforeClass ();). Возможно, вы захотите иметь флаг в базовом классе, если вы запускаете его из приложения, чтобы определить, является ли он уже настроен или нет. Таким образом, он запускается только один раз, если вы запускаете его обоими возможными методами (например, из eclipse для личного тестирования и через ANT для выпуска сборки).

Похоже, это ошибка Eclipse или, по крайней мере, неожиданные результаты.

Как насчет того, чтобы ваш метод @BeforeClass вызывал пустой метод specificBeforeClass (), который может или не может быть перезаписан подклассами, например:

public class AbstractTestClass {
  @BeforeClass
  public void generalBeforeClass() {
    // do stuff
    specificBeforeClass();
  }

  protected void specificBeforeClass() {}
}

public class SpecificTest {
  @Override
  protected void specificBeforeClass() {
    // Do specific stuff
  }

  // Tests
}

dependsOnMethod можно использовать.

например в случае Spring (AbstractTestNGSpringContextTests)

@BeforeClass(alwaysRun = true, dependsOnMethods = "springTestContextPrepareTestInstance")

Проверьте свой отчет об импорте. Должен быть

import org.testng.annotations.BeforeClass;

нет

import org.junit.BeforeClass;

Это работает для меня -

abstract class A {
    @BeforeClass
    doInitialization() {...}
}

class B extends A {
    @Override
    @BeforeClass
    doInitialization() { 

       //do class specific init

    }   

    @Test
    doTests() {...}
}

Почему бы вам не попытаться создать абстрактный метод doSpecialInit () в своем суперклассе, вызываемый из вашего аннотированного метода BeforeClass в суперклассе.

Поэтому разработчики, наследующие ваш класс, вынуждены реализовать этот метод.

Здесь есть еще одно простое решение.

Моя конкретная ситуация заключается в том, что мне нужно внедрить фиктивные службы из «BeforeClass» в подкласс до выполнения «BeforeClass» в суперклассе.

Для этого просто используйте @ClassRule в подклассе.

Например:

@ClassRule
public static ExternalResource mocksInjector = new ExternalResource() {
    @Override
    protected void before() {
        // inject my mock services here
        // Note: this is executed before the parent class @BeforeClass
    }
};

Надеюсь, это поможет. Это может эффективно выполнять статическую настройку в «обратном» порядке.

Сегодня я столкнулся с подобной проблемой, единственная разница заключалась в том, что базовый класс не был абстрактным.

Вот мой случай

public class A {
    @BeforeClass
    private void doInitialization() {...}
}

public class B extends A {
    @BeforeClass
    private void doSpecificInitialization() {...}

    @Test
    public void doTests() {...}
}

Оказалось, что метод @BeforeClass из класса A никогда не выполнялся.

• A.doInitialization () -> ЭТО НИКОГДА НЕ ВЫПОЛНЯЛОСЬ тихо
• B.doSpecificInitialization ()
• B.doTests ()

Играя с модификаторами конфиденциальности, я обнаружил, что TestNG не будет выполнять @BeforeClass аннотированный метод из унаследованного класса , если метод не виден из наследника класса

Итак, это будет работать:

public class A {
    @BeforeClass
    private void doInitialization() {...}
}

public class B extends A {
    @BeforeClass
    //Here a privacy modifier matters -> please make sure your method is public or protected so it will be visible for ancestors
    protected void doSpecificInitialization() {...}

    @Test
    public void doTests() {...}
}

В результате происходит следующее:

• A.doInitialization ()
• B.doSpecificInitialization ()
• B.doTests ()

В моем случае (JUnit) у меня есть те же методы, которые называются setup () в базовом и производном классах. В этом случае вызывается только метод производного класса, и он вызывает метод базового класса.

Лучший и более чистый способ добиться этого с использованием наследования может быть следующим:

abstract class A {

    @BeforeClass
    void doInitialization() {}
}

class B extends A {

    @Override
    @BeforeClass
    void doInitialization() {
        super.doInitialization();
    }

    @Test
    void doTests() {}
}