--- a/toolkit/components/telemetry/tests/unit/test_TelemetryEvents.js
+++ b/toolkit/components/telemetry/tests/unit/test_TelemetryEvents.js
@@ -390,17 +390,17 @@ add_task(async function test_dynamicEven
     // Only "test4" should have been recorded.
     ["telemetry.test.dynamic", "test4", "object1"],
   ];
   snapshot = Telemetry.snapshotEvents(OPTIN, true);
   Assert.equal(snapshot.dynamic.length, 1, "Should have one opt-out event in the snapshot.");
   Assert.deepEqual(snapshot.dynamic.map(e => e.slice(1)), expected);
 });
 
-add_task(function* test_dynamicEventRegistrationValidation() {
+add_task(async function test_dynamicEventRegistrationValidation() {
   Telemetry.canRecordExtended = true;
   Telemetry.clearEvents();
 
   // Test registration of invalid categories.
   Assert.throws(() => Telemetry.registerEvents("telemetry+test+dynamic", {
       "test1": {
         methods: ["test1"],
         objects: ["object1"],
@@ -516,17 +516,17 @@ add_task(function* test_dynamicEventRegi
       objects: ["object1"],
       extra_keys: ["a1", "a2", "a3", "a4", "a5", "a6", "a7", "a8", "a9", "a10"],
     },
   });
 });
 
 // When add-ons update, they may re-register some of the dynamic events.
 // Test through some possible scenarios.
-add_task(function* test_dynamicEventRegisterAgain() {
+add_task(async function test_dynamicEventRegisterAgain() {
   Telemetry.canRecordExtended = true;
   Telemetry.clearEvents();
 
   const category = "telemetry.test.register.again";
   let events = {
     "test1": {
       methods: ["test1"],
       objects: ["object1"],

--- a/toolkit/components/telemetry/tests/unit/test_TelemetryHistograms.js
+++ b/toolkit/components/telemetry/tests/unit/test_TelemetryHistograms.js
@@ -1002,17 +1002,17 @@ function test_keyed_subsession() {
   Assert.equal(snapshot[KEY].sum, 1);
   Assert.equal(subsession[KEY].sum, 1);
 
   subsession = h.subsessionSnapshot();
   Assert.ok(!(KEY in subsession));
   Assert.equal(h.subsessionSnapshot(KEY).sum, 0);
 });
 
-add_task(function* test_keyed_keys() {
+add_task(async function test_keyed_keys() {
   let h = Telemetry.getKeyedHistogramById("TELEMETRY_TEST_KEYED_KEYS");
   h.clear();
   Telemetry.clearScalars();
 
   // The |add| method should not throw for keys that are not allowed.
   h.add("testkey", true);
   h.add("thirdKey", false);
   h.add("not-allowed", true);

--- a/toolkit/components/telemetry/tests/unit/test_TelemetryScalars.js
+++ b/toolkit/components/telemetry/tests/unit/test_TelemetryScalars.js
@@ -531,17 +531,17 @@ add_task(async function test_keyed_max_k
   // Check that all the keys recorded the expected values.
   let expectedValue = 0;
   keyNamesSet.forEach(keyName => {
     Assert.equal(keyedScalars[KEYED_UINT_SCALAR][keyName], expectedValue++,
                  "The key must contain the expected value.");
   });
 });
 
-add_task(function* test_dynamicScalars_registration() {
+add_task(async function test_dynamicScalars_registration() {
   Telemetry.clearScalars();
 
   const TEST_CASES = [
     {
       "category": "telemetry.test",
       "data": {
         "missing_kind": {
           keyed: false,
@@ -601,17 +601,17 @@ add_task(function* test_dynamicScalars_r
   ];
 
   for (let testCase of TEST_CASES) {
     Assert.throws(() => Telemetry.registerScalars(testCase.category, testCase.data),
                   testCase.evaluation, testCase.description);
   }
 });
 
-add_task(function* test_dynamicScalars_doubleRegistration() {
+add_task(async function test_dynamicScalars_doubleRegistration() {
   Telemetry.clearScalars();
 
   // Register a test scalar.
   Telemetry.registerScalars("telemetry.test.dynamic", {
     "double_registration_1": {
       kind: Ci.nsITelemetry.SCALAR_TYPE_COUNT,
       record_on_release: true
     },
@@ -659,17 +659,17 @@ add_task(function* test_dynamicScalars_d
   // Attempt to record and make sure that no recording happens.
   Telemetry.scalarAdd("telemetry.test.dynamic.double_registration_2", 1);
   scalars =
     getProcessScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, "dynamic", false, false);
   Assert.equal(scalars["telemetry.test.dynamic.double_registration_2"], 3,
                "The recorded scalar must contain the right value.");
 });
 
-add_task(function* test_dynamicScalars_recording() {
+add_task(async function test_dynamicScalars_recording() {
   Telemetry.clearScalars();
 
   // Disable extended recording so that we will just record opt-out.
   Telemetry.canRecordExtended = false;
 
   // Register some test scalars.
   Telemetry.registerScalars("telemetry.test.dynamic", {
     "record_optout": {