// NewTTLWithCallback creates a new cache with a time-based eviction model that will invoke the supplied
// callback on all evictions. See also: NewTTL.
func NewTTLWithCallback(defaultExpiration time.Duration, evictionInterval time.Duration, callback EvictionCallback) ExpiringCache {
	c := &ttlCache{
		defaultExpiration: defaultExpiration,
		callback:          callback,
	}

	c.baseTimeNanos = time.Now().UnixNano()
	if evictionInterval > 0 {

 * under the License.
 */
package org.apache.maven;

import org.apache.maven.execution.MavenSession;

/**
 * Allows core extensions to participate in Maven build session lifecycle.
 *
 * All callback methods (will) follow beforeXXX/afterXXX naming pattern to
 * indicate at what lifecycle point it is being called.
 *
 * @see <a href="https://maven.apache.org/examples/maven-3-lifecycle-extensions.html">example</a>

                                    ],
                                    "title": "Callback Url",
                                }
                            )
                            | IsDict(
                                # TODO: remove when deprecating Pydantic v1
                                {
                                    "title": "Callback Url",
                                    "maxLength": 2083,

    def ansiExecutor = new DefaultAnsiExecutor(target, colorMap, factory, consoleMetaData, writeCursor, newLineListener)

    def "writing a long line that wraps will callback the listener"() {
        given:
        consoleMetaData.cols >> TERMINAL_WIDTH
        Cursor writePos = Cursor.at(3, 0)
        int startRow = writePos.row
        String text = "A" * TERMINAL_WIDTH +

 */
package org.codelibs.fess.ds;

import org.codelibs.fess.ds.callback.IndexUpdateCallback;
import org.codelibs.fess.entity.DataStoreParams;
import org.codelibs.fess.es.config.exentity.DataConfig;

public interface DataStore {

    void store(DataConfig config, IndexUpdateCallback callback, DataStoreParams initParamMap);

    void stop();

                    throw new IllegalStateException("beforeAll callback");
                }
            }

            class ThrowingAfterAllCallback implements AfterAllCallback {
                @Override
                public void afterAll(ExtensionContext context) {
                    throw new CustomException("afterAll callback");
                }
            }

                                 std::move(callback));
}

absl::Status SavedModelV2Bundle::RecurseObjectsToRestore(
    const SavedObject* saved_object, int saved_object_node_id,
    const TrackableObjectGraph::TrackableObject* trackable_object,
    std::string object_name, absl::flat_hash_set<int>* seen_trackable_node_ids,
    RestoreObjectsCallback callback) {
  // Callback if any attributes or slot variables.

 * limitations under the License.
 */
package okhttp.android.testapp

import android.os.Bundle
import androidx.activity.ComponentActivity
import okhttp3.Call
import okhttp3.Callback
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okio.IOException

class MainActivity : ComponentActivity() {

	}
	// Only frames in the test package are checked.
	want := []string{
		"test._Cfunc_backtrace",
		"test.testCallbackCallersSEH.func1.1",
		"test.testCallbackCallersSEH.func1",
		"test.goCallback",
		"test._Cfunc_callback",
		"test.nestedCall.func1",
		"test.nestedCall",
		"test.testCallbackCallersSEH",
		"test.TestCallbackCallersSEH",
	}
	pc := make([]uintptr, 100)
	n := 0
	nestedCall(func() {

import okhttp3.Call
import okhttp3.Callback
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response

class AsynchronousGet {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request.Builder()
        .url("http://publicobject.com/helloworld.txt")
        .build()

    client.newCall(request).enqueue(
      object : Callback {
        override fun onFailure(