provider.get()

        then: "beforeValueObtained callback is notified"
        1 * computationListener.beforeValueObtained()

        then: "afterValueObtained callback is notified"
        1 * computationListener.afterValueObtained()

        then: "valueObtained is notified"
        obtainedValues.size() == 1
        obtainedValues[0].valueSourceType == EchoValueSource

		t.Error(err)
	}
	if handled != 0 {
		t.Errorf("notified workload handler %d times, want %d", handled, 0)
	}

	if err := f(nil, &v1.Pod{ObjectMeta: pod1, Status: v1.PodStatus{Conditions: readyCondition, PodIP: ip, Phase: v1.PodPending}}, model.EventUpdate); err != nil {
		t.Error(err)
	}
	if handled != 1 {
		t.Errorf("notified workload handler %d times, want %d", handled, 1)
	}

        }

        private List<Dispatch<MethodInvocation>> startNotification(boolean includeLogger) {
            takeOwnership();

            if (!notified) {
                maybeAddPendingRegistrations(type);
                notified = true;
            }

            // Take a snapshot while holding lock
            List<Dispatch<MethodInvocation>> result = includeLogger ? allWithLogger : allWithNoLogger;

        when:
        manager.apply(rulesClass)

        then:
        1 * target.applyRules(null, rulesClass)

        and:
        manager.hasPlugin("foo")
    }

    def "action is notified when rules plugin with id is applied by class"() {
        def action = Mock(Action)

        given:
        addPluginId("foo", rulesClass)
        manager.withPlugin("foo", action)

        when:

    }

    /**
     * Adds a closure to be notified before a test is executed. A {@link TestDescriptor} instance is passed to the closure as a parameter.
     *
     * @param closure The closure to call.
     */
    public void beforeTest(Closure closure) {
        addDispatchAsTestListener("beforeTest", closure);
    }

    /**

	lockWithRank(&l.lock, lockRankNotifyList)
	s := l.head
	l.head = nil
	l.tail = nil

	// Update the next ticket to be notified. We can set it to the current
	// value of wait because any previous waiters are already in the list
	// or will notice that they have already been notified when trying to
	// add themselves to the list.
	atomic.Store(&l.notify, l.wait.Load())
	unlock(&l.lock)

    @UnsupportedWithConfigurationCache
    def taskCanAccessTaskGraph() {
        buildFile << """
            boolean notified = false
            task a(dependsOn: 'b') {
                doLast { task ->
                    assert notified
                    assert gradle.taskGraph.hasTask(task)
                    assert gradle.taskGraph.hasTask(':a')

          nanos: Long,
        ) {
          taskRunner.assertThreadHoldsLock()
          check(waitingCoordinatorTask == null)
          if (nanos == 0L) return

          // Yield until notified, interrupted, or the duration elapses.
          val waitUntil = nanoTime + nanos
          val self = currentTask
          waitingCoordinatorTask = self
          waitingCoordinatorNotified = false

        then:
        IllegalStateException e = thrown()
        e.message == "Cannot notify listeners of type TestFooListener as these listeners are already being notified."

        and:
        1 * fooListener1.foo("param") >> {
            manager.getBroadcaster(TestFooListener.class).foo("param2")
        }
        0 * _

        when:

	keyFile                   string
	dynamicCertificateContent *dynamiccertificates.DynamicCertKeyPairContent
	currentTLSCertificate     atomic.Pointer[tls.Certificate]
}

// Enqueue implements the functions to be notified when the serving cert content changes.
func (m *kubeletServerCertificateDynamicFileManager) Enqueue() {
	certContent, keyContent := m.dynamicCertificateContent.CurrentCertKeyContent()