}
	name := fmt.Sprintf("%s.%s", s.Resource, s.Group)
	c.callbacks[name] = append(c.callbacks[name], func() {
		if features.EnableUnsafeAssertions && c.stop == nil {
			log.Fatalf("CRD Watcher callback called without stop set")
		}
		// Call the callback
		f(c.stop)
	})
	return false
}

func (c *crdWatcher) known(s schema.GroupVersionResource) bool {
	// From the spec: "Its name MUST be in the format <.spec.name>.<.spec.group>."

     * callback.
     */
    public void setBuildStarted(long buildStarted) {
        this.buildStarted = buildStarted;
    }

    /**
     * Should be set with a timestamp from a {@link org.gradle.BuildListener#settingsEvaluated}
     * callback.
     */
    public void setSettingsEvaluated(long settingsEvaluated) {

    }

    /**
     * Registers a callback to be called just before the service represented by this provider is stopped.
     * The callback runs even if the service wasn't created.
     * This provider is used as a callback argument.
     * <p>
     * The service will only be stopped after completing all registered callbacks.
     *
     * @param stopAction the callback
     */

		values:    map[string]ref.Val{},
		callbacks: map[string]GetFieldFunc{},
	}
}

// Append adds the given field with its name and callback.
func (m *MapValue) Append(name string, callback GetFieldFunc) {
	m.knownValues = append(m.knownValues, name)
	m.callbacks[name] = callback
}

// Contains checks if the key is known to the map
func (m *MapValue) Contains(key ref.Val) ref.Val {
	v, found := m.Find(key)

     */
    void abort();

    /**
     * Add a callback upon unrecoverable errors, e.g. broken connection. Should not throw any exceptions because
     * this is the last line of defense.
     * @param handler the callback
     */
    void addUnrecoverableErrorHandler(Action<Throwable> handler);

     *
     * @param baseHost The host specified by the user.
     * @param allowInsecureProtocol If true, allows HTTP based connections.
     * @param insecureBaseHost Callback when the base host URL is insecure.
     * @param insecureRedirect Callback when the server returns an 30x redirect to an insecure server.
     */
    public static HttpRedirectVerifier create(
        @Nullable URI baseHost,
        boolean allowInsecureProtocol,

namespace {

// jax2tf sets `stablehlo.custom_call`'s target name as `tf.call_tf_function`
// to represent calling a TF host callback function.
constexpr llvm::StringRef kTfTargetName = "tf.call_tf_function";

// `tf.backend_config` is a DictionaryAttr, JAX2TF sets the value of its
// string attribute `caller_name` to the TF host callback function's name.
constexpr llvm::StringRef kTfBackendConfigAttrName = "tf.backend_config";

    }

    public static long scroll(final String index, final Function<SearchHit, Boolean> callback) {
        final SearchEngineClient client = ComponentUtil.getSearchEngineClient();
        return client.<SearchHit> scrollSearch(index, searchRequestBuilder -> true, (searchResponse, hit) -> hit,
                hit -> callback.apply(hit));
    }

    listener = new MockFutureListener(resultFuture);
  }

  public void testFutureGetBeforeCallback() throws Exception {
    // Verify that get throws a timeout exception before the callback is called.
    assertThrows(TimeoutException.class, () -> resultFuture.get(1L, TimeUnit.MILLISECONDS));
  }

  public void testFutureGetThrowsWrappedException() throws Exception {
    inputFuture.setException(EXCEPTION);

			ResourceVersion: resourceVersion,
		},
		Data: map[string]string{
			"mesh": "trustDomain: cluster.local",
		},
	}
}

var (
	mu     sync.Mutex
	called bool
	newCM  *v1.ConfigMap
)

func callback(cm *v1.ConfigMap) {
	mu.Lock()
	defer mu.Unlock()
	called = true
	newCM = cm
}

func getCalled() bool {
	mu.Lock()
	defer mu.Unlock()
	return called
}

func getCM() *v1.ConfigMap {