core: Use global Jazzer.js object for callbacks

Author: bertschneider

packages/core/callback.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import { getOrSetJazzerJsGlobal } from "./api";
+
 export type Thunk = () => void;
 
 /**
@@ -33,24 +35,23 @@ export class Callbacks {
 	}
 
 	runAfterEachCallbacks() {
-		for (const c of this._afterEachCallbacks) {
-			c();
-		}
+		this._afterEachCallbacks.forEach((c) => c());
 	}
 
 	runBeforeEachCallbacks() {
-		for (const c of this._beforeEachCallbacks) {
-			c();
-		}
+		this._beforeEachCallbacks.forEach((c) => c());
 	}
 }
 
-export const callbacks = new Callbacks();
+const defaultCallbacks = new Callbacks();
+export function getCallbacks(): Callbacks {
+	return getOrSetJazzerJsGlobal("callbacks", defaultCallbacks);
+}
 
 export function registerAfterEachCallback(callback: Thunk) {
-	callbacks.registerAfterEachCallback(callback);
+	getCallbacks().registerAfterEachCallback(callback);
 }
 
 export function registerBeforeEachCallback(callback: Thunk) {
-	callbacks.registerBeforeEachCallback(callback);
+	getCallbacks().registerBeforeEachCallback(callback);
 }

packages/core/callbacks.test.ts

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2023 Code Intelligence GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+	getCallbacks,
+	registerAfterEachCallback,
+	registerBeforeEachCallback,
+} from "./callback";
+
+describe("callbacks", () => {
+	beforeEach(() => {
+		globalThis.JazzerJS = new Map();
+	});
+
+	it("executes registered beforeEach callbacks", () => {
+		const callback = jest.fn();
+		registerBeforeEachCallback(callback);
+		registerBeforeEachCallback(callback);
+		registerBeforeEachCallback(callback);
+		const callbacks = getCallbacks();
+		callbacks.runBeforeEachCallbacks();
+		expect(callback).toBeCalledTimes(3);
+	});
+
+	it("executes registered afterEach callbacks", () => {
+		const callback = jest.fn();
+		registerAfterEachCallback(callback);
+		registerAfterEachCallback(callback);
+		registerAfterEachCallback(callback);
+		const callbacks = getCallbacks();
+		callbacks.runAfterEachCallbacks();
+		expect(callback).toBeCalledTimes(3);
+	});
+});

packages/core/core.ts

@@ -35,7 +35,7 @@ import {
 	MemorySyncIdStrategy,
 	registerInstrumentor,
 } from "@jazzer.js/instrumentor";
-import { callbacks } from "./callback";
+import { getCallbacks } from "./callback";
 import { ensureFilepath, importModule } from "./utils";
 import { buildFuzzerOption, Options } from "./options";
 import { jazzerJs } from "./globals";
@@ -334,6 +334,7 @@ export function wrapFuzzFunctionForBugDetection(
 		return (data: Buffer): unknown | Promise<unknown> => {
 			let fuzzTargetError: unknown;
 			let result: unknown | Promise<unknown> = undefined;
+			const callbacks = getCallbacks();
 			try {
 				callbacks.runBeforeEachCallbacks();
 				result = (originalFuzzFn as fuzzer.FuzzTargetAsyncOrValue)(data);
@@ -365,6 +366,7 @@ export function wrapFuzzFunctionForBugDetection(
 			data: Buffer,
 			done: (err?: Error) => void,
 		): unknown | Promise<unknown> => {
+			const callbacks = getCallbacks();
 			try {
 				callbacks.runBeforeEachCallbacks();
 				// Return result of fuzz target to enable sanity checks in C++ part.