public BuildServiceProviderNagger(WorkExecutionTracker taskExecutionTracker) {
        this.taskExecutionTracker = taskExecutionTracker;
    }

    @Override
    public void beforeGet(BuildServiceProvider<?, ?> provider) {
        currentTask().ifPresent(task -> {
            if (!isServiceRequiredBy(task, provider)) {
                nagAboutUndeclaredUsageOf(provider, task);
            }
        });

        throw new UnsupportedOperationException("Unexpected provider for a build service: " + service);
    }

    public interface Listener {
        Listener EMPTY = provider -> {
        };

        void beforeGet(BuildServiceProvider<?, ?> provider);
    }

    @Override
    public boolean isImmutable() {
        return true;
    }

    @Override
    public Object unpackState() {

    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        return Value.of(getInstance());
    }

    private T getInstance() {
        listener.beforeGet(this);
        synchronized (instanceLock) {
            if (instance == null) {
                instance = instantiate();
            }
            return instance.get();
        }
    }

package org.gradle;

import org.testng.annotations.BeforeTest;

public abstract class AbstractTest {

    protected int value = 0;

    @BeforeTest
    public void before() {
        value = 1;
    }

package org.gradle;

import org.testng.annotations.BeforeTest;

public class TestSetup {
    @BeforeTest
    public void setupTest() {
    }

        clazz.assertTestCaseStderr("m1", is("beforeTest err\nm1 err\nafterTest err\n"))
        clazz.assertTestCaseStderr("m2", is("beforeTest err\nm2 err\nafterTest err\n"))
        clazz.assertTestCaseStdout("m1", is("beforeTest out\nm1 out\nafterTest out\n"))
        clazz.assertTestCaseStdout("m2", is("beforeTest out\nm2 out\nafterTest out\n"))

 * limitations under the License.
 */

package org.gradle.failurepolicy;

import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class TestWithFailureInConfigMethod {

    @BeforeTest
    public void fail() {
        throw new RuntimeException("Failure in @BeforeTest");
    }

    @Test
    public void someTest() {}

        when:
        //simulating TestNG, where we don't receive beforeSuite for classes
        collector.beforeSuite(root)

        collector.beforeTest(test1)
        collector.beforeTest(test2)

        collector.afterTest(test1, result1)
        collector.afterTest(test2, result2)

        collector.afterSuite(root, new DefaultTestResult(FAILURE, 0, 500, 2, 1, 1, []))

                    System.out.println("beforeClass out"); System.err.println("beforeClass err");
                }

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

                @Test public void m1() {
                    System.out.print("m1: ");

                    System.err.println("beforeClass err");
                }

                ${beforeTestAnnotation}
                public void beforeTest() {
                    System.out.println("beforeTest out");
                    System.err.println("beforeTest err");
                }

                @Test public void m1() {
                    System.out.println("m1 out");