Bug 1188888 - Part 1 - Refactor test_nsITelemetry.js. r=dexter
authorGeorg Fritzsche <georg.fritzsche@googlemail.com>
Wed, 20 Jul 2016 17:10:23 +0200
changeset 345894 6a5f0538b3c907f9a9f5a4851aaae2494e08b165
parent 345893 63a62a6c3cddfefae733a428c24def6063d320d1
child 345895 58344005efca56b77c38459955f4099ad9f68f22
push id6389
push userraliiev@mozilla.com
push dateMon, 19 Sep 2016 13:38:22 +0000
treeherdermozilla-beta@01d67bfe6c81 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdexter
bugs1188888
milestone50.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1188888 - Part 1 - Refactor test_nsITelemetry.js. r=dexter
toolkit/components/telemetry/tests/unit/test_nsITelemetry.js
--- a/toolkit/components/telemetry/tests/unit/test_nsITelemetry.js
+++ b/toolkit/components/telemetry/tests/unit/test_nsITelemetry.js
@@ -1,35 +1,67 @@
 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 
 const INT_MAX = 0x7FFFFFFF;
 
 Cu.import("resource://gre/modules/Services.jsm", this);
+Cu.import("resource://gre/modules/TelemetryUtils.jsm", this);
 
-function test_expired_histogram() {
-  var histogram_id = "FOOBAR";
-  var test_expired_id = "TELEMETRY_TEST_EXPIRED";
-  var clone_id = "ExpiredClone";
-  var dummy = Telemetry.newHistogram(histogram_id, "28.0a1", Telemetry.HISTOGRAM_EXPONENTIAL, 1, 2, 3);
-  var dummy_clone = Telemetry.histogramFrom(clone_id, test_expired_id);
-  var rh = Telemetry.registeredHistograms(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, []);
-  Assert.ok(!!rh);
+// Return an array of numbers from lower up to, excluding, upper
+function numberRange(lower, upper)
+{
+  let a = [];
+  for (let i=lower; i<upper; ++i) {
+    a.push(i);
+  }
+  return a;
+}
 
-  dummy.add(1);
-  dummy_clone.add(1);
-
-  do_check_eq(Telemetry.histogramSnapshots["__expired__"], undefined);
-  do_check_eq(Telemetry.histogramSnapshots[histogram_id], undefined);
-  do_check_eq(Telemetry.histogramSnapshots[test_expired_id], undefined);
-  do_check_eq(Telemetry.histogramSnapshots[clone_id], undefined);
-  do_check_eq(rh[test_expired_id], undefined);
+function expect_fail(f) {
+  let failed = false;
+  try {
+    f();
+    failed = false;
+  } catch (e) {
+    failed = true;
+  }
+  do_check_true(failed);
 }
 
-function test_histogram(histogram_type, name, min, max, bucket_count) {
+function expect_success(f) {
+  let succeeded = false;
+  try {
+    f();
+    succeeded = true;
+  } catch (e) {
+    succeeded = false;
+  }
+  do_check_true(succeeded);
+}
+
+function compareHistograms(h1, h2) {
+  let s1 = h1.snapshot();
+  let s2 = h2.snapshot();
+
+  do_check_eq(s1.histogram_type, s2.histogram_type);
+  do_check_eq(s1.min, s2.min);
+  do_check_eq(s1.max, s2.max);
+  do_check_eq(s1.sum, s2.sum);
+
+  do_check_eq(s1.counts.length, s2.counts.length);
+  for (let i = 0; i < s1.counts.length; i++)
+    do_check_eq(s1.counts[i], s2.counts[i]);
+
+  do_check_eq(s1.ranges.length, s2.ranges.length);
+  for (let i = 0; i < s1.ranges.length; i++)
+    do_check_eq(s1.ranges[i], s2.ranges[i]);
+}
+
+function check_histogram(histogram_type, name, min, max, bucket_count) {
   var h = Telemetry.newHistogram(name, "never", histogram_type, min, max, bucket_count);
   var r = h.snapshot().ranges;
   var sum = 0;
   for(let i=0;i<r.length;i++) {
     var v = r[i];
     sum += v;
     h.add(v);
   }
@@ -65,40 +97,56 @@ function test_histogram(histogram_type, 
 
   h.add(0);
   h.add(1);
   var c = h.snapshot().counts;
   do_check_eq(c[0], 1);
   do_check_eq(c[1], 1);
 }
 
-function expect_fail(f) {
-  let failed = false;
-  try {
-    f();
-    failed = false;
-  } catch (e) {
-    failed = true;
-  }
-  do_check_true(failed);
-}
+// This MUST be the very first test of this file.
+add_task({
+  skip_if: () => gIsAndroid
+},
+function* test_instantiate() {
+  const ID = "TELEMETRY_TEST_COUNT";
+  let h = Telemetry.getHistogramById(ID);
+
+  // Instantiate the subsession histogram through |add| and make sure they match.
+  // This MUST be the first use of "TELEMETRY_TEST_COUNT" in this file, otherwise
+  // |add| will not instantiate the histogram.
+  h.add(1);
+  let snapshot = h.snapshot();
+  let subsession = Telemetry.snapshotSubsessionHistograms();
+  Assert.equal(snapshot.sum, subsession[ID].sum,
+               "Histogram and subsession histogram sum must match.");
+  // Clear the histogram, so we don't void the assumptions from the other tests.
+  h.clear();
+});
 
-function expect_success(f) {
-  let succeeded = false;
-  try {
-    f();
-    succeeded = true;
-  } catch (e) {
-    succeeded = false;
+add_task(function* test_parameterChecks() {
+  let kinds = [Telemetry.HISTOGRAM_EXPONENTIAL, Telemetry.HISTOGRAM_LINEAR]
+  for (let histogram_type of kinds) {
+    let [min, max, bucket_count] = [1, INT_MAX - 1, 10]
+    check_histogram(histogram_type, "test::"+histogram_type, min, max, bucket_count);
+
+    const nh = Telemetry.newHistogram;
+    expect_fail(() => nh("test::min", "never", histogram_type, 0, max, bucket_count));
+    expect_fail(() => nh("test::bucket_count", "never", histogram_type, min, max, 1));
   }
-  do_check_true(succeeded);
-}
+});
 
-function test_boolean_histogram()
-{
+add_task(function* test_noSerialization() {
+  // Instantiate the storage for this histogram and make sure it doesn't
+  // get reflected into JS, as it has no interesting data in it.
+  Telemetry.getHistogramById("NEWTAB_PAGE_PINNED_SITES_COUNT");
+  do_check_false("NEWTAB_PAGE_PINNED_SITES_COUNT" in Telemetry.histogramSnapshots);
+});
+
+add_task(function* test_boolean_histogram() {
   var h = Telemetry.newHistogram("test::boolean histogram", "never", Telemetry.HISTOGRAM_BOOLEAN);
   var r = h.snapshot().ranges;
   // boolean histograms ignore numeric parameters
   do_check_eq(uneval(r), uneval([0, 1, 2]))
   var sum = 0
   for(var i=0;i<r.length;i++) {
     var v = r[i];
     sum += v;
@@ -107,20 +155,19 @@ function test_boolean_histogram()
   h.add(true);
   h.add(false);
   var s = h.snapshot();
   do_check_eq(s.histogram_type, Telemetry.HISTOGRAM_BOOLEAN);
   // last bucket should always be 0 since .add parameters are normalized to either 0 or 1
   do_check_eq(s.counts[2], 0);
   do_check_eq(s.sum, 3);
   do_check_eq(s.counts[0], 2);
-}
+});
 
-function test_flag_histogram()
-{
+add_task(function* test_flag_histogram() {
   var h = Telemetry.newHistogram("test::flag histogram", "never", Telemetry.HISTOGRAM_FLAG);
   var r = h.snapshot().ranges;
   // Flag histograms ignore numeric parameters.
   do_check_eq(uneval(r), uneval([0, 1, 2]));
   // Should already have a 0 counted.
   var c = h.snapshot().counts;
   var s = h.snapshot().sum;
   do_check_eq(uneval(c), uneval([1, 0, 0]));
@@ -133,68 +180,49 @@ function test_flag_histogram()
   do_check_eq(s2, 1);
   // Should only switch counts once.
   h.add(1);
   var c3 = h.snapshot().counts;
   var s3 = h.snapshot().sum;
   do_check_eq(uneval(c3), uneval([0, 1, 0]));
   do_check_eq(s3, 1);
   do_check_eq(h.snapshot().histogram_type, Telemetry.HISTOGRAM_FLAG);
-}
+});
 
-function test_count_histogram()
-{
+add_task(function* test_count_histogram() {
   let h = Telemetry.newHistogram("test::count histogram", "never", Telemetry.HISTOGRAM_COUNT, 1, 2, 3);
   let s = h.snapshot();
   do_check_eq(uneval(s.ranges), uneval([0, 1, 2]));
   do_check_eq(uneval(s.counts), uneval([0, 0, 0]));
   do_check_eq(s.sum, 0);
   h.add();
   s = h.snapshot();
   do_check_eq(uneval(s.counts), uneval([1, 0, 0]));
   do_check_eq(s.sum, 1);
   h.add();
   s = h.snapshot();
   do_check_eq(uneval(s.counts), uneval([2, 0, 0]));
   do_check_eq(s.sum, 2);
-}
+});
 
-function test_getHistogramById() {
+add_task(function* test_getHistogramById() {
   try {
     Telemetry.getHistogramById("nonexistent");
     do_throw("This can't happen");
   } catch (e) {
 
   }
   var h = Telemetry.getHistogramById("CYCLE_COLLECTOR");
   var s = h.snapshot();
   do_check_eq(s.histogram_type, Telemetry.HISTOGRAM_EXPONENTIAL);
   do_check_eq(s.min, 1);
   do_check_eq(s.max, 10000);
-}
-
-function compareHistograms(h1, h2) {
-  let s1 = h1.snapshot();
-  let s2 = h2.snapshot();
-
-  do_check_eq(s1.histogram_type, s2.histogram_type);
-  do_check_eq(s1.min, s2.min);
-  do_check_eq(s1.max, s2.max);
-  do_check_eq(s1.sum, s2.sum);
+});
 
-  do_check_eq(s1.counts.length, s2.counts.length);
-  for (let i = 0; i < s1.counts.length; i++)
-    do_check_eq(s1.counts[i], s2.counts[i]);
-
-  do_check_eq(s1.ranges.length, s2.ranges.length);
-  for (let i = 0; i < s1.ranges.length; i++)
-    do_check_eq(s1.ranges[i], s2.ranges[i]);
-}
-
-function test_histogramFrom() {
+add_task(function* test_histogramFrom() {
   // Test one histogram of each type.
   let names = [
       "CYCLE_COLLECTOR",      // EXPONENTIAL
       "GC_REASON_2",          // LINEAR
       "GC_RESET",             // BOOLEAN
       "TELEMETRY_TEST_FLAG",  // FLAG
       "TELEMETRY_TEST_COUNT", // COUNT
   ];
@@ -211,31 +239,97 @@ function test_histogramFrom() {
   let testFlag = Telemetry.getHistogramById("TELEMETRY_TEST_FLAG");
   testFlag.add(1);
   let testCount = Telemetry.getHistogramById("TELEMETRY_TEST_COUNT");
   testCount.add();
   let clone = Telemetry.histogramFrom("FlagClone", "TELEMETRY_TEST_FLAG");
   compareHistograms(testFlag, clone);
   clone = Telemetry.histogramFrom("CountClone", "TELEMETRY_TEST_COUNT");
   compareHistograms(testCount, clone);
-}
+});
 
-function test_getSlowSQL() {
+add_task(function* test_getSlowSQL() {
   var slow = Telemetry.slowSQL;
   do_check_true(("mainThread" in slow) && ("otherThreads" in slow));
-}
+});
 
-function test_getWebrtc() {
+add_task(function* test_getWebrtc() {
   var webrtc = Telemetry.webrtcStats;
   do_check_true("IceCandidatesStats" in webrtc);
   var icestats = webrtc.IceCandidatesStats;
   do_check_true(("webrtc" in icestats) && ("loop" in icestats));
-}
+});
+
+// Check that telemetry doesn't record in private mode
+add_task(function* test_privateMode() {
+  var h = Telemetry.newHistogram("test::private_mode_boolean", "never", Telemetry.HISTOGRAM_BOOLEAN);
+  var orig = h.snapshot();
+  Telemetry.canRecordExtended = false;
+  h.add(1);
+  do_check_eq(uneval(orig), uneval(h.snapshot()));
+  Telemetry.canRecordExtended = true;
+  h.add(1);
+  do_check_neq(uneval(orig), uneval(h.snapshot()));
+});
+
+// Check that telemetry records only when it is suppose to.
+add_task(function* test_histogramRecording() {
+  // Check that no histogram is recorded if both base and extended recording are off.
+  Telemetry.canRecordBase = false;
+  Telemetry.canRecordExtended = false;
+
+  let h = Telemetry.getHistogramById("TELEMETRY_TEST_RELEASE_OPTOUT");
+  h.clear();
+  let orig = h.snapshot();
+  h.add(1);
+  Assert.equal(orig.sum, h.snapshot().sum);
+
+  // Check that only base histograms are recorded.
+  Telemetry.canRecordBase = true;
+  h.add(1);
+  Assert.equal(orig.sum + 1, h.snapshot().sum,
+               "Histogram value should have incremented by 1 due to recording.");
 
-function test_addons() {
+  // Extended histograms should not be recorded.
+  h = Telemetry.getHistogramById("TELEMETRY_TEST_RELEASE_OPTIN");
+  orig = h.snapshot();
+  h.add(1);
+  Assert.equal(orig.sum, h.snapshot().sum,
+               "Histograms should be equal after recording.");
+
+  // Runtime created histograms should not be recorded.
+  h = Telemetry.newHistogram("test::runtime_created_boolean", "never", Telemetry.HISTOGRAM_BOOLEAN);
+  orig = h.snapshot();
+  h.add(1);
+  Assert.equal(orig.sum, h.snapshot().sum,
+               "Histograms should be equal after recording.");
+
+  // Check that extended histograms are recorded when required.
+  Telemetry.canRecordExtended = true;
+
+  h.add(1);
+  Assert.equal(orig.sum + 1, h.snapshot().sum,
+               "Runtime histogram value should have incremented by 1 due to recording.");
+
+  h = Telemetry.getHistogramById("TELEMETRY_TEST_RELEASE_OPTIN");
+  orig = h.snapshot();
+  h.add(1);
+  Assert.equal(orig.sum + 1, h.snapshot().sum,
+               "Histogram value should have incremented by 1 due to recording.");
+
+  // Check that base histograms are still being recorded.
+  h = Telemetry.getHistogramById("TELEMETRY_TEST_RELEASE_OPTOUT");
+  h.clear();
+  orig = h.snapshot();
+  h.add(1);
+  Assert.equal(orig.sum + 1, h.snapshot().sum,
+               "Histogram value should have incremented by 1 due to recording.");
+});
+
+add_task(function* test_addons() {
   var addon_id = "testing-addon";
   var fake_addon_id = "fake-addon";
   var name1 = "testing-histogram1";
   var register = Telemetry.registerAddonHistogram;
   expect_success(() =>
                  register(addon_id, name1, Telemetry.HISTOGRAM_LINEAR, 1, 5, 6));
   // Can't register the same histogram multiple times.
   expect_fail(() =>
@@ -311,96 +405,60 @@ function test_addons() {
   do_check_false(name2 in snapshots[flag_addon]);
 
   // Check that we can remove addon histograms.
   Telemetry.unregisterAddonHistograms(addon_id);
   snapshots = Telemetry.addonHistogramSnapshots;
   do_check_false(addon_id in snapshots);
   // Make sure other addons are unaffected.
   do_check_true(extra_addon in snapshots);
-}
-
-// Check that telemetry doesn't record in private mode
-function test_privateMode() {
-  var h = Telemetry.newHistogram("test::private_mode_boolean", "never", Telemetry.HISTOGRAM_BOOLEAN);
-  var orig = h.snapshot();
-  Telemetry.canRecordExtended = false;
-  h.add(1);
-  do_check_eq(uneval(orig), uneval(h.snapshot()));
-  Telemetry.canRecordExtended = true;
-  h.add(1);
-  do_check_neq(uneval(orig), uneval(h.snapshot()));
-}
+});
 
-// Check that telemetry records only when it is suppose to.
-function test_histogramRecording() {
-  // Check that no histogram is recorded if both base and extended recording are off.
-  Telemetry.canRecordBase = false;
-  Telemetry.canRecordExtended = false;
-
-  let h = Telemetry.getHistogramById("TELEMETRY_TEST_RELEASE_OPTOUT");
-  h.clear();
-  let orig = h.snapshot();
-  h.add(1);
-  Assert.equal(orig.sum, h.snapshot().sum);
+add_task(function* test_expired_histogram() {
+  var histogram_id = "FOOBAR";
+  var test_expired_id = "TELEMETRY_TEST_EXPIRED";
+  var clone_id = "ExpiredClone";
+  var dummy = Telemetry.newHistogram(histogram_id, "28.0a1", Telemetry.HISTOGRAM_EXPONENTIAL, 1, 2, 3);
+  var dummy_clone = Telemetry.histogramFrom(clone_id, test_expired_id);
+  var rh = Telemetry.registeredHistograms(Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN, []);
+  Assert.ok(!!rh);
 
-  // Check that only base histograms are recorded.
-  Telemetry.canRecordBase = true;
-  h.add(1);
-  Assert.equal(orig.sum + 1, h.snapshot().sum,
-               "Histogram value should have incremented by 1 due to recording.");
+  dummy.add(1);
+  dummy_clone.add(1);
 
-  // Extended histograms should not be recorded.
-  h = Telemetry.getHistogramById("TELEMETRY_TEST_RELEASE_OPTIN");
-  orig = h.snapshot();
-  h.add(1);
-  Assert.equal(orig.sum, h.snapshot().sum,
-               "Histograms should be equal after recording.");
+  do_check_eq(Telemetry.histogramSnapshots["__expired__"], undefined);
+  do_check_eq(Telemetry.histogramSnapshots[histogram_id], undefined);
+  do_check_eq(Telemetry.histogramSnapshots[test_expired_id], undefined);
+  do_check_eq(Telemetry.histogramSnapshots[clone_id], undefined);
+  do_check_eq(rh[test_expired_id], undefined);
+});
 
-  // Runtime created histograms should not be recorded.
-  h = Telemetry.newHistogram("test::runtime_created_boolean", "never", Telemetry.HISTOGRAM_BOOLEAN);
-  orig = h.snapshot();
-  h.add(1);
-  Assert.equal(orig.sum, h.snapshot().sum,
-               "Histograms should be equal after recording.");
-
-  // Check that extended histograms are recorded when required.
-  Telemetry.canRecordExtended = true;
+add_task(function* test_keyed_histogram() {
+  // Check that invalid names get rejected.
 
-  h.add(1);
-  Assert.equal(orig.sum + 1, h.snapshot().sum,
-               "Runtime histogram value should have incremented by 1 due to recording.");
-
-  h = Telemetry.getHistogramById("TELEMETRY_TEST_RELEASE_OPTIN");
-  orig = h.snapshot();
-  h.add(1);
-  Assert.equal(orig.sum + 1, h.snapshot().sum,
-               "Histogram value should have incremented by 1 due to recording.");
+  let threw = false;
+  try {
+    Telemetry.newKeyedHistogram("test::invalid # histogram", "never", Telemetry.HISTOGRAM_BOOLEAN);
+  } catch (e) {
+    // This should throw as we reject names with the # separator
+    threw = true;
+  }
+  Assert.ok(threw, "newKeyedHistogram should have thrown");
 
-  // Check that base histograms are still being recorded.
-  h = Telemetry.getHistogramById("TELEMETRY_TEST_RELEASE_OPTOUT");
-  h.clear();
-  orig = h.snapshot();
-  h.add(1);
-  Assert.equal(orig.sum + 1, h.snapshot().sum,
-               "Histogram value should have incremented by 1 due to recording.");
-}
+  threw = false;
+  try {
+    Telemetry.getKeyedHistogramById("test::unknown histogram", "never", Telemetry.HISTOGRAM_BOOLEAN);
+  } catch (e) {
+    // This should throw as it is an unknown ID
+    threw = true;
+  }
+  Assert.ok(threw, "getKeyedHistogramById should have thrown");
+});
 
-// Return an array of numbers from lower up to, excluding, upper
-function numberRange(lower, upper)
-{
-  let a = [];
-  for (let i=lower; i<upper; ++i) {
-    a.push(i);
-  }
-  return a;
-}
-
-function test_keyed_boolean_histogram()
-{
+add_task(function* test_keyed_boolean_histogram() {
   const KEYED_ID = "test::keyed::boolean";
   let KEYS = numberRange(0, 2).map(i => "key" + (i + 1));
   KEYS.push("漢語");
   let histogramBase = {
     "min": 1,
     "max": 2,
     "histogram_type": 2,
     "sum": 1,
@@ -436,20 +494,19 @@ function test_keyed_boolean_histogram()
   Assert.deepEqual(h.snapshot(), testSnapShot);
 
   let allSnapshots = Telemetry.keyedHistogramSnapshots;
   Assert.deepEqual(allSnapshots[KEYED_ID], testSnapShot);
 
   h.clear();
   Assert.deepEqual(h.keys(), []);
   Assert.deepEqual(h.snapshot(), {});
-}
+});
 
-function test_keyed_count_histogram()
-{
+add_task(function* test_keyed_count_histogram() {
   const KEYED_ID = "test::keyed::count";
   const KEYS = numberRange(0, 5).map(i => "key" + (i + 1));
   let histogramBase = {
     "min": 1,
     "max": 2,
     "histogram_type": 4,
     "sum": 0,
     "ranges": [0, 1, 2],
@@ -492,20 +549,19 @@ function test_keyed_count_histogram()
   Assert.deepEqual(h.snapshot(), testSnapShot);
 
   let allSnapshots = Telemetry.keyedHistogramSnapshots;
   Assert.deepEqual(allSnapshots[KEYED_ID], testSnapShot);
 
   h.clear();
   Assert.deepEqual(h.keys(), []);
   Assert.deepEqual(h.snapshot(), {});
-}
+});
 
-function test_keyed_flag_histogram()
-{
+add_task(function* test_keyed_flag_histogram() {
   const KEYED_ID = "test::keyed::flag";
   let h = Telemetry.newKeyedHistogram(KEYED_ID, "never", Telemetry.HISTOGRAM_FLAG);
 
   const KEY = "default";
   h.add(KEY, true);
 
   let testSnapshot = {};
   testSnapshot[KEY] = {
@@ -521,19 +577,19 @@ function test_keyed_flag_histogram()
   Assert.deepEqual(h.snapshot(), testSnapshot);
 
   let allSnapshots = Telemetry.keyedHistogramSnapshots;
   Assert.deepEqual(allSnapshots[KEYED_ID], testSnapshot);
 
   h.clear();
   Assert.deepEqual(h.keys(), []);
   Assert.deepEqual(h.snapshot(), {});
-}
+});
 
-function test_keyed_histogram_recording() {
+add_task(function* test_keyed_histogram_recording() {
   // Check that no histogram is recorded if both base and extended recording are off.
   Telemetry.canRecordBase = false;
   Telemetry.canRecordExtended = false;
 
   const TEST_KEY = "record_foo";
   let h = Telemetry.getKeyedHistogramById("TELEMETRY_TEST_KEYED_RELEASE_OPTOUT");
   h.clear();
   h.add(TEST_KEY, 1);
@@ -571,19 +627,19 @@ function test_keyed_histogram_recording(
   Assert.equal(h.snapshot(TEST_KEY).sum, 1,
                "The keyed histogram should record the correct value.");
 
   // Check that base histograms are still being recorded.
   h = Telemetry.getKeyedHistogramById("TELEMETRY_TEST_KEYED_RELEASE_OPTOUT");
   h.clear();
   h.add(TEST_KEY, 1);
   Assert.equal(h.snapshot(TEST_KEY).sum, 1);
-}
+});
 
-function test_histogram_recording_enabled() {
+add_task(function* test_histogram_recording_enabled() {
   Telemetry.canRecordBase = true;
   Telemetry.canRecordExtended = true;
 
   // Check that a "normal" histogram respects recording-enabled on/off
   var h = Telemetry.getHistogramById("TELEMETRY_TEST_COUNT");
   var orig = h.snapshot();
 
   h.add(1);
@@ -620,20 +676,19 @@ function test_histogram_recording_enable
   Assert.equal(orig.sum + 1, h.snapshot().sum,
                "When recording is enabled add should record.");
 
   // Restore to disabled
   Telemetry.setHistogramRecordingEnabled("TELEMETRY_TEST_COUNT_INIT_NO_RECORD", false);
   h.add(1);
   Assert.equal(orig.sum + 1, h.snapshot().sum,
                "When recording is disabled add should not record.");
+});
 
-}
-
-function test_keyed_histogram_recording_enabled() {
+add_task(function* test_keyed_histogram_recording_enabled() {
   Telemetry.canRecordBase = true;
   Telemetry.canRecordExtended = true;
 
   // Check RecordingEnabled for keyed histograms which are recording by default
   const TEST_KEY = "record_foo";
   let h = Telemetry.getKeyedHistogramById("TELEMETRY_TEST_KEYED_RELEASE_OPTOUT");
 
   h.clear();
@@ -665,49 +720,19 @@ function test_keyed_histogram_recording_
   Assert.equal(h.snapshot(TEST_KEY).sum, 1,
     "Keyed histogram add should record when recording is enabled");
 
   // Restore to disabled
   Telemetry.setHistogramRecordingEnabled("TELEMETRY_TEST_KEYED_COUNT_INIT_NO_RECORD", false);
   h.add(TEST_KEY, 1);
   Assert.equal(h.snapshot(TEST_KEY).sum, 1,
     "Keyed histogram add should not record when recording is disabled");
-}
-
-function test_keyed_histogram() {
-  // Check that invalid names get rejected.
-
-  let threw = false;
-  try {
-    Telemetry.newKeyedHistogram("test::invalid # histogram", "never", Telemetry.HISTOGRAM_BOOLEAN);
-  } catch (e) {
-    // This should throw as we reject names with the # separator
-    threw = true;
-  }
-  Assert.ok(threw, "newKeyedHistogram should have thrown");
+});
 
-  threw = false;
-  try {
-    Telemetry.getKeyedHistogramById("test::unknown histogram", "never", Telemetry.HISTOGRAM_BOOLEAN);
-  } catch (e) {
-    // This should throw as it is an unknown ID
-    threw = true;
-  }
-  Assert.ok(threw, "getKeyedHistogramById should have thrown");
-
-  // Check specific keyed histogram types working properly.
-
-  test_keyed_boolean_histogram();
-  test_keyed_count_histogram();
-  test_keyed_flag_histogram();
-  test_keyed_histogram_recording();
-}
-
-function test_datasets()
-{
+add_task(function* test_datasets() {
   // Check that datasets work as expected.
 
   const RELEASE_CHANNEL_OPTOUT = Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTOUT;
   const RELEASE_CHANNEL_OPTIN  = Ci.nsITelemetry.DATASET_RELEASE_CHANNEL_OPTIN;
 
   // Histograms should default to the extended dataset
   let h = Telemetry.getHistogramById("TELEMETRY_TEST_FLAG");
   Assert.equal(h.dataset(), RELEASE_CHANNEL_OPTIN);
@@ -740,45 +765,22 @@ function test_datasets()
   registered = Telemetry.registeredKeyedHistograms(RELEASE_CHANNEL_OPTIN, []);
   registered = new Set(registered);
   Assert.ok(registered.has("TELEMETRY_TEST_KEYED_FLAG"));
   Assert.ok(registered.has("TELEMETRY_TEST_KEYED_RELEASE_OPTOUT"));
   registered = Telemetry.registeredKeyedHistograms(RELEASE_CHANNEL_OPTOUT, []);
   registered = new Set(registered);
   Assert.ok(!registered.has("TELEMETRY_TEST_KEYED_FLAG"));
   Assert.ok(registered.has("TELEMETRY_TEST_KEYED_RELEASE_OPTOUT"));
-}
-
-function test_instantiate() {
-  if (gIsAndroid) {
-    // We don't support subsessions yet on Android.
-    return;
-  }
-
-  const ID = "TELEMETRY_TEST_COUNT";
-  let h = Telemetry.getHistogramById(ID);
+});
 
-  // Instantiate the subsession histogram through |add| and make sure they match.
-  // This MUST be the first use of "TELEMETRY_TEST_COUNT" in this file, otherwise
-  // |add| will not instantiate the histogram.
-  h.add(1);
-  let snapshot = h.snapshot();
-  let subsession = Telemetry.snapshotSubsessionHistograms();
-  Assert.equal(snapshot.sum, subsession[ID].sum,
-               "Histogram and subsession histogram sum must match.");
-  // Clear the histogram, so we don't void the assumptions from the other tests.
-  h.clear();
-}
-
-function test_subsession() {
-  if (gIsAndroid) {
-    // We don't support subsessions yet on Android.
-    return;
-  }
-
+add_task({
+  skip_if: () => gIsAndroid
+},
+function* test_subsession() {
   const ID = "TELEMETRY_TEST_COUNT";
   const FLAG = "TELEMETRY_TEST_FLAG";
   let h = Telemetry.getHistogramById(ID);
   let flag = Telemetry.getHistogramById(FLAG);
 
   // Both original and duplicate should start out the same.
   h.clear();
   let snapshot = Telemetry.histogramSnapshots;
@@ -849,24 +851,22 @@ function test_subsession() {
   Assert.ok(ID in snapshot);
   Assert.ok(ID in subsession);
   Assert.ok(FLAG in snapshot);
   Assert.ok(FLAG in subsession);
   Assert.equal(snapshot[ID].sum, 1);
   Assert.equal(subsession[ID].sum, 0);
   Assert.equal(snapshot[FLAG].sum, 1);
   Assert.equal(subsession[FLAG].sum, 0);
-}
+});
 
-function test_keyed_subsession() {
-  if (gIsAndroid) {
-    // We don't support subsessions yet on Android.
-    return;
-  }
-
+add_task({
+  skip_if: () => gIsAndroid
+},
+function* test_keyed_subsession() {
   let h = Telemetry.getKeyedHistogramById("TELEMETRY_TEST_KEYED_FLAG");
   const KEY = "foo";
 
   // Both original and subsession should start out the same.
   h.clear();
   Assert.ok(!(KEY in h.snapshot()));
   Assert.ok(!(KEY in h.subsessionSnapshot()));
   Assert.equal(h.snapshot(KEY).sum, 0);
@@ -899,54 +899,9 @@ function test_keyed_subsession() {
   Assert.ok(KEY in snapshot);
   Assert.ok(KEY in 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);
-}
-
-function generateUUID() {
-  let str = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator).generateUUID().toString();
-  // strip {}
-  return str.substring(1, str.length - 1);
-}
-
-function run_test()
-{
-  // This MUST be the very first test of this file.
-  test_instantiate();
-
-  let kinds = [Telemetry.HISTOGRAM_EXPONENTIAL, Telemetry.HISTOGRAM_LINEAR]
-  for (let histogram_type of kinds) {
-    let [min, max, bucket_count] = [1, INT_MAX - 1, 10]
-    test_histogram(histogram_type, "test::"+histogram_type, min, max, bucket_count);
-
-    const nh = Telemetry.newHistogram;
-    expect_fail(() => nh("test::min", "never", histogram_type, 0, max, bucket_count));
-    expect_fail(() => nh("test::bucket_count", "never", histogram_type, min, max, 1));
-  }
-
-  // Instantiate the storage for this histogram and make sure it doesn't
-  // get reflected into JS, as it has no interesting data in it.
-  let h = Telemetry.getHistogramById("NEWTAB_PAGE_PINNED_SITES_COUNT");
-  do_check_false("NEWTAB_PAGE_PINNED_SITES_COUNT" in Telemetry.histogramSnapshots);
-
-  test_boolean_histogram();
-  test_flag_histogram();
-  test_count_histogram();
-  test_getHistogramById();
-  test_histogramFrom();
-  test_getSlowSQL();
-  test_getWebrtc();
-  test_privateMode();
-  test_histogramRecording();
-  test_addons();
-  test_expired_histogram();
-  test_keyed_histogram();
-  test_datasets();
-  test_subsession();
-  test_keyed_subsession();
-  test_histogram_recording_enabled();
-  test_keyed_histogram_recording_enabled();
-}
+});