--- a/toolkit/components/extensions/test/xpcshell/test_ext_telemetry.js
+++ b/toolkit/components/extensions/test/xpcshell/test_ext_telemetry.js
@@ -24,24 +24,30 @@ add_task(async function test_telemetry_w
       browser.test.notifyPass("telemetry_permission");
     },
     permissions: [],
     doneSignal: "telemetry_permission",
   });
 });
 
 add_task(async function test_telemetry_scalar_add() {
+  Services.telemetry.clearScalars();
+
   await run({
     backgroundScript: async () => {
-      // TODO: verify value
       await browser.telemetry.scalarAdd("telemetry.test.unsigned_int_kind", 1);
       browser.test.notifyPass("scalar_add");
     },
     doneSignal: "scalar_add",
   });
+
+  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
+  equal(scalars.parent["telemetry.test.unsigned_int_kind"], 1);
+
+  Services.telemetry.clearScalars();
 });
 
 add_task(async function test_telemetry_scalar_add_unknown_name() {
   let {messages} = await promiseConsoleOutput(async () => {
     await run({
       backgroundScript: async () => {
         await browser.telemetry.scalarAdd("telemetry.test.does_not_exist", 1);
         browser.test.notifyPass("scalar_add_unknown_name");
@@ -79,23 +85,30 @@ add_task(async function test_telemetry_s
     });
   });
 
   messages = messages.filter(msg => /Attempting to manage a keyed scalar as a scalar/);
   equal(messages.length, 1, "Telemetry should throw if a keyed scalar is incremented");
 });
 
 add_task(async function test_telemetry_scalar_set() {
+  Services.telemetry.clearScalars();
+
   await run({
     backgroundScript: async () => {
       await browser.telemetry.scalarSet("telemetry.test.boolean_kind", true);
       browser.test.notifyPass("scalar_set");
     },
     doneSignal: "scalar_set",
   });
+
+  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
+  equal(scalars.parent["telemetry.test.boolean_kind"], true);
+
+  Services.telemetry.clearScalars();
 });
 
 add_task(async function test_telemetry_scalar_set_unknown_name() {
   let {messages} = await promiseConsoleOutput(async function() {
     await run({
       backgroundScript: async () => {
         await browser.telemetry.scalarSet("telemetry.test.does_not_exist", true);
         browser.test.notifyPass("scalar_set_unknown_name");
@@ -104,23 +117,30 @@ add_task(async function test_telemetry_s
     });
   });
 
   messages = messages.filter(msg => /Unknown scalar/);
   equal(messages.length, 1, "Telemetry should throw if an unknown scalar is set");
 });
 
 add_task(async function test_telemetry_scalar_set_maximum() {
+  Services.telemetry.clearScalars();
+
   await run({
     backgroundScript: async () => {
       await browser.telemetry.scalarSetMaximum("telemetry.test.unsigned_int_kind", 123);
       browser.test.notifyPass("scalar_set_maximum");
     },
     doneSignal: "scalar_set_maximum",
   });
+
+  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
+  equal(scalars.parent["telemetry.test.unsigned_int_kind"], 123);
+
+  Services.telemetry.clearScalars();
 });
 
 add_task(async function test_telemetry_scalar_set_maximum_unknown_name() {
   let {messages} = await promiseConsoleOutput(async function() {
     await run({
       backgroundScript: async () => {
         await browser.telemetry.scalarSetMaximum("telemetry.test.does_not_exist", 1);
         browser.test.notifyPass("scalar_set_maximum_unknown_name");
@@ -142,54 +162,62 @@ add_task(async function test_telemetry_s
         "The second 'value' argument to scalarSetMaximum must be a scalar");
       browser.test.notifyPass("scalar_set_maximum_illegal_value");
     },
     doneSignal: "scalar_set_maximum_illegal_value",
   });
 });
 
 add_task(async function test_telemetry_record_event() {
+  Services.telemetry.clearEvents();
   Services.telemetry.setEventRecordingEnabled("telemetry.test", true);
 
   await run({
     backgroundScript: async () => {
       await browser.telemetry.recordEvent("telemetry.test", "test1", "object1");
       browser.test.notifyPass("record_event_ok");
     },
     doneSignal: "record_event_ok",
   });
 
   let events = Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
   equal(events.parent.length, 1);
   equal(events.parent[0][1], "telemetry.test");
 
+  Services.telemetry.setEventRecordingEnabled("telemetry.test", false);
   Services.telemetry.clearEvents();
 });
 
 add_task(async function test_telemetry_register_scalars_string() {
+  Services.telemetry.clearScalars();
+
   await run({
     backgroundScript: async () => {
       await browser.telemetry.registerScalars("telemetry.test.dynamic", {
         "webext_string": {
           kind: browser.telemetry.ScalarType.STRING,
           keyed: false,
           record_on_release: true,
         },
       });
       await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string", "hello");
       browser.test.notifyPass("register_scalars_string");
     },
     doneSignal: "register_scalars_string",
   });
 
-  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
+  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
   equal(scalars.dynamic["telemetry.test.dynamic.webext_string"], "hello");
+
+  Services.telemetry.clearScalars();
 });
 
 add_task(async function test_telemetry_register_scalars_multiple() {
+  Services.telemetry.clearScalars();
+
   await run({
     backgroundScript: async () => {
       await browser.telemetry.registerScalars("telemetry.test.dynamic", {
         "webext_string": {
           kind: browser.telemetry.ScalarType.STRING,
           keyed: false,
           record_on_release: true,
         },
@@ -201,81 +229,95 @@ add_task(async function test_telemetry_r
       });
       await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string", "hello");
       await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_string_too", "world");
       browser.test.notifyPass("register_scalars_multiple");
     },
     doneSignal: "register_scalars_multiple",
   });
 
-  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
+  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
   equal(scalars.dynamic["telemetry.test.dynamic.webext_string"], "hello");
   equal(scalars.dynamic["telemetry.test.dynamic.webext_string_too"], "world");
+
+  Services.telemetry.clearScalars();
 });
 
 add_task(async function test_telemetry_register_scalars_boolean() {
+  Services.telemetry.clearScalars();
+
   await run({
     backgroundScript: async () => {
       await browser.telemetry.registerScalars("telemetry.test.dynamic", {
         "webext_boolean": {
           kind: browser.telemetry.ScalarType.BOOLEAN,
           keyed: false,
           record_on_release: true,
         },
       });
       await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_boolean", true);
       browser.test.notifyPass("register_scalars_boolean");
     },
     doneSignal: "register_scalars_boolean",
   });
 
-  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
+  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
   equal(scalars.dynamic["telemetry.test.dynamic.webext_boolean"], true);
+
+  Services.telemetry.clearScalars();
 });
 
 add_task(async function test_telemetry_register_scalars_count() {
+  Services.telemetry.clearScalars();
+
   await run({
     backgroundScript: async () => {
       await browser.telemetry.registerScalars("telemetry.test.dynamic", {
         "webext_count": {
           kind: browser.telemetry.ScalarType.COUNT,
           keyed: false,
           record_on_release: true,
         },
       });
       await browser.telemetry.scalarSet("telemetry.test.dynamic.webext_count", 123);
       browser.test.notifyPass("register_scalars_count");
     },
     doneSignal: "register_scalars_count",
   });
 
-  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
+  const scalars = Services.telemetry.snapshotScalars(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
   equal(scalars.dynamic["telemetry.test.dynamic.webext_count"], 123);
+
+  Services.telemetry.clearScalars();
 });
 
 add_task(async function test_telemetry_register_events() {
+  Services.telemetry.clearEvents();
+
   await run({
     backgroundScript: async () => {
       await browser.telemetry.registerEvents("telemetry.test.dynamic", {
         "test1": {
           methods: ["test1"],
           objects: ["object1"],
           extra_keys: [],
         },
       });
       await browser.telemetry.recordEvent("telemetry.test.dynamic", "test1", "object1");
       browser.test.notifyPass("register_events");
     },
     doneSignal: "register_events",
   });
 
-  let events = Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, true);
+  let events = Services.telemetry.snapshotEvents(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN);
   let expected = [["telemetry.test.dynamic", "test1", "object1"]];
   equal(events.dynamic.length, expected.length);
   deepEqual(events.dynamic.map(e => e.slice(1)), expected);
+
+  Services.telemetry.clearEvents();
 });
 
 add_task(async function test_telemetry_submit_ping() {
   await run({
     backgroundScript: async () => {
       await browser.telemetry.submitPing("webext-test", {}, {});
       browser.test.notifyPass("submit_ping");
     },