[tools/perf] Migrate clients to LegacyPageTestCase

This new class makes it easier to write tests for LegacyPageTest
implementations, and is compatible with the add hoc measurements that
they normally write.

Depends on catapult CL:
https://chromium-review.googlesource.com/c/catapult/+/1862517

Bug: 999484
Change-Id: I13c64fdf7cb7181ac34306a124868d408bc99742
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1863292Reviewed-by: Ravi Mistry <rmistry@chromium.org>
Reviewed-by: Caleb Rouleau <crouleau@chromium.org>
Commit-Queue: Juan Antonio Navarro Pérez <perezju@chromium.org>
Cr-Commit-Position: refs/heads/master@{#706470}

tools/perf/benchmarks/blink_perf_unittest.py

 # Copyright 2017 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
+from __future__ import division
+
 import os
-import shutil
-import tempfile
 import unittest
 
 from telemetry import decorators
 from telemetry import story
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
+from telemetry.testing import legacy_page_test_case
 from telemetry.timeline import async_slice
 from telemetry.timeline import model as model_module
 
-
 from benchmarks import blink_perf
 
 
-class BlinkPerfTest(page_test_test_case.PageTestTestCase):
-  _BLINK_PERF_TEST_DATA_DIR = os.path.join(os.path.dirname(__file__),
-      '..', '..', '..', 'third_party', 'blink', 'perf_tests',
-      'test_data')
+_BLINK_PERF_TEST_DATA_DIR = os.path.join(os.path.dirname(__file__),
+    '..', '..', '..', 'third_party', 'blink', 'perf_tests', 'test_data')
+_BLINK_PERF_RESOURCES_DIR = os.path.join(os.path.dirname(__file__),
+    '..', '..', '..', 'third_party', 'blink', 'perf_tests', 'resources')
 
-  _BLINK_PERF_RESOURCES_DIR = os.path.join(os.path.dirname(__file__),
-      '..', '..', '..', 'third_party', 'blink', 'perf_tests',
-      'resources')
-  def setUp(self):
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=tempfile.mkdtemp())
-    # pylint: disable=protected-access
-    self._measurement = blink_perf._BlinkPerfMeasurement()
-    # pylint: enable=protected-access
 
-  def tearDown(self):
-    shutil.rmtree(self._options.output_dir)
+def _Mean(values):
+  return sum(values) / len(values)
+
 
-  def _CreateStorySetForTestFile(self, test_file_name):
-    story_set = story.StorySet(base_dir=self._BLINK_PERF_TEST_DATA_DIR,
-        serving_dirs={self._BLINK_PERF_TEST_DATA_DIR,
-                      self._BLINK_PERF_RESOURCES_DIR})
+class BlinkPerfTest(legacy_page_test_case.LegacyPageTestCase):
+  def setUp(self):
+    super(BlinkPerfTest, self).setUp()
     # pylint: disable=protected-access
-    page = blink_perf._BlinkPerfPage('file://' + test_file_name, story_set,
-        base_dir=story_set.base_dir, name=test_file_name)
+    self.blink_page_test = blink_perf._BlinkPerfMeasurement()
     # pylint: enable=protected-access
-    story_set.AddStory(page)
+
+  @staticmethod
+  def CreateStorySetForTest(url):
+    story_set = story.StorySet(
+        base_dir=_BLINK_PERF_TEST_DATA_DIR,
+        serving_dirs=[_BLINK_PERF_TEST_DATA_DIR, _BLINK_PERF_RESOURCES_DIR])
+    assert url.startswith('file://'), 'Expected local URI, got %s' % url
+    blink_page = blink_perf._BlinkPerfPage(  # pylint: disable=protected-access
+        url, story_set, base_dir=story_set.base_dir, name=url[len('file://'):])
+    story_set.AddStory(blink_page)
     return story_set
 
   def testBlinkPerfTracingMetricsForMeasureTime(self):
-    results = self.RunMeasurement(
-        self._measurement,
-        self._CreateStorySetForTestFile('append-child-measure-time.html'),
-        run_options=self._options)
-    self.assertFalse(results.had_failures)
-    self.assertEquals(len(list(results.IterRunsWithTraces())), 1)
-
-    frame_view_layouts = results.FindAllPageSpecificValuesNamed(
-        'LocalFrameView::layout')
-    self.assertEquals(len(frame_view_layouts), 1)
+    measurements = self.RunPageTest(
+        self.blink_page_test, 'file://append-child-measure-time.html')
+    self.assertIn('trace.html', self.test_result['outputArtifacts'])
+
+    frame_view_layouts = measurements['LocalFrameView::layout']['samples']
     # append-child-measure-time.html specifies 5 iterationCount.
-    self.assertEquals(len(frame_view_layouts[0].values), 5)
-    self.assertGreater(frame_view_layouts[0].mean, 0.001)
+    self.assertEquals(len(frame_view_layouts), 5)
+    self.assertGreater(_Mean(frame_view_layouts), 0.001)
 
-    update_layout_trees = results.FindAllPageSpecificValuesNamed(
-        'UpdateLayoutTree')
-    self.assertEquals(len(update_layout_trees), 1)
+    update_layout_trees = measurements['UpdateLayoutTree']['samples']
     # append-child-measure-time.html specifies 5 iterationCount.
-    self.assertEquals(len(update_layout_trees[0].values), 5)
-    self.assertGreater(update_layout_trees[0].mean, 0.001)
+    self.assertEquals(len(update_layout_trees), 5)
+    self.assertGreater(_Mean(update_layout_trees), 0.001)
 
   def testBlinkPerfTracingMetricsForMeasureFrameTime(self):
-    results = self.RunMeasurement(
-        self._measurement,
-        self._CreateStorySetForTestFile(
-            'color-changes-measure-frame-time.html'),
-        run_options=self._options)
-    self.assertFalse(results.had_failures)
-    self.assertEquals(len(list(results.IterRunsWithTraces())), 1)
-
-    frame_view_prepaints = results.FindAllPageSpecificValuesNamed(
-        'LocalFrameView::RunPrePaintLifecyclePhase')
-
-    self.assertEquals(len(frame_view_prepaints), 1)
+    measurements = self.RunPageTest(
+        self.blink_page_test, 'file://color-changes-measure-frame-time.html')
+    self.assertIn('trace.html', self.test_result['outputArtifacts'])
+
+    frame_view_prepaints = measurements[
+        'LocalFrameView::RunPrePaintLifecyclePhase']['samples']
+
     # color-changes-measure-frame-time.html specifies 9 iterationCount.
-    self.assertEquals(len(frame_view_prepaints[0].values), 9)
-    self.assertGreater(frame_view_prepaints[0].mean, 0.001)
+    self.assertEquals(len(frame_view_prepaints), 9)
+    self.assertGreater(_Mean(frame_view_prepaints), 0.001)
 
-    frame_view_painttrees = results.FindAllPageSpecificValuesNamed(
-        'LocalFrameView::RunPaintLifecyclePhase')
-    self.assertEquals(len(frame_view_painttrees), 1)
+    frame_view_painttrees = measurements[
+        'LocalFrameView::RunPaintLifecyclePhase']['samples']
     # color-changes-measure-frame-time.html specifies 9 iterationCount.
-    self.assertEquals(len(frame_view_painttrees[0].values), 9)
-    self.assertGreater(frame_view_painttrees[0].mean, 0.001)
+    self.assertEquals(len(frame_view_painttrees), 9)
+    self.assertGreater(_Mean(frame_view_painttrees), 0.001)
 
   def testBlinkPerfTracingMetricsForMeasurePageLoadTime(self):
-    results = self.RunMeasurement(
-        self._measurement,
-        self._CreateStorySetForTestFile(
-            'simple-html-measure-page-load-time.html'),
-        run_options=self._options)
-    self.assertFalse(results.had_failures)
-    self.assertEquals(len(list(results.IterRunsWithTraces())), 1)
-
-    create_child_frame = results.FindAllPageSpecificValuesNamed(
-        'WebLocalFrameImpl::createChildframe')
-    self.assertEquals(len(create_child_frame), 1)
-    # color-changes-measure-frame-time.html specifies 7 iterationCount.
-    self.assertEquals(len(create_child_frame[0].values), 7)
-    self.assertGreater(create_child_frame[0].mean, 0.001)
+    measurements = self.RunPageTest(
+        self.blink_page_test, 'file://simple-html-measure-page-load-time.html')
+    self.assertIn('trace.html', self.test_result['outputArtifacts'])
 
-    post_layout_task = results.FindAllPageSpecificValuesNamed(
-        'LocalFrameView::performPostLayoutTasks')
-    self.assertEquals(len(post_layout_task), 1)
+    create_child_frame = measurements[
+        'WebLocalFrameImpl::createChildframe']['samples']
     # color-changes-measure-frame-time.html specifies 7 iterationCount.
-    self.assertEquals(len(post_layout_task[0].values), 7)
-    self.assertGreater(post_layout_task[0].mean, 0.001)
+    self.assertEquals(len(create_child_frame), 7)
+    self.assertGreater(_Mean(create_child_frame), 0.001)
 
+    post_layout_task = measurements[
+        'LocalFrameView::performPostLayoutTasks']['samples']
+    # color-changes-measure-frame-time.html specifies 7 iterationCount.
+    self.assertEquals(len(post_layout_task), 7)
+    self.assertGreater(_Mean(post_layout_task), 0.001)
 
   @decorators.Disabled('mac')  # Flaky on mac: crbug.com/960554
   def testBlinkPerfTracingMetricsForMeasureAsync(self):
-    results = self.RunMeasurement(
-        self._measurement,
-        self._CreateStorySetForTestFile('simple-blob-measure-async.html'),
-        run_options=self._options)
-    self.assertFalse(results.had_failures)
-    self.assertEquals(len(list(results.IterRunsWithTraces())), 1)
-
-    blob_requests = results.FindAllPageSpecificValuesNamed(
-        'BlobRequest')
-    blob_readers = results.FindAllPageSpecificValuesNamed(
-        'BlobReader')
-    self.assertEquals(len(blob_requests), 1)
-    self.assertEquals(len(blob_readers), 1)
+    measurements = self.RunPageTest(
+        self.blink_page_test, 'file://simple-blob-measure-async.html')
+    self.assertIn('trace.html', self.test_result['outputArtifacts'])
+
+    blob_requests = measurements['BlobRequest']['samples']
+    blob_readers = measurements['BlobReader']['samples']
     # simple-blob-measure-async.html specifies 6 iterationCount.
-    self.assertEquals(len(blob_requests[0].values), 6)
-    self.assertEquals(len(blob_readers[0].values), 6)
+    self.assertEquals(len(blob_requests), 6)
+    self.assertEquals(len(blob_readers), 6)
 
     # TODO(mek): Delete non-mojo code paths when blobs are always using mojo.
-    using_mojo = blob_readers[0].mean > 0.001
+    using_mojo = _Mean(blob_readers) > 0.001
     if using_mojo:
-      self.assertEquals(blob_requests[0].mean, 0)
-      self.assertGreater(blob_readers[0].mean, 0.001)
+      self.assertEquals(_Mean(blob_requests), 0)
+      self.assertGreater(_Mean(blob_readers), 0.001)
     else:
-      self.assertGreater(blob_requests[0].mean, 0.001)
-      self.assertEquals(blob_readers[0].mean, 0)
+      self.assertGreater(_Mean(blob_requests), 0.001)
+      self.assertEquals(_Mean(blob_readers), 0)
 
     if using_mojo:
-      read_data = results.FindAllPageSpecificValuesNamed(
-          'BlobReader::ReadMore')
+      read_data = measurements['BlobReader::ReadMore']['samples']
     else:
-      read_data = results.FindAllPageSpecificValuesNamed(
-          'BlobRequest::ReadRawData')
-    self.assertEquals(len(read_data), 1)
+      read_data = measurements['BlobRequest::ReadRawData']['samples']
     # simple-blob-measure-async.html specifies 6 iterationCount.
-    self.assertEquals(len(read_data[0].values), 6)
-    self.assertGreater(read_data[0].mean, 0.001)
+    self.assertEquals(len(read_data), 6)
+    self.assertGreater(_Mean(read_data), 0.001)
 
   def testBlinkPerfLifecycleMethods(self):
-    results = self.RunMeasurement(
-        self._measurement,
-        self._CreateStorySetForTestFile('lifecycle-methods.html'),
-        run_options=self._options)
-    self.assertFalse(results.had_failures)
-    self.assertEquals(len(list(results.IterRunsWithTraces())), 0)
+    self.RunPageTest(self.blink_page_test, 'file://lifecycle-methods.html')
+    self.assertNotIn('trace.html', self.test_result['outputArtifacts'])
 
   def testExtraChromeCategories(self):
-    self._options.extra_chrome_categories = 'cc,blink'
-    results = self.RunMeasurement(
-        self._measurement,
-        self._CreateStorySetForTestFile('lifecycle-methods.html'),
-        run_options=self._options)
-    self.assertFalse(results.had_failures)
-    self.assertEquals(len(list(results.IterRunsWithTraces())), 1)
+    self.options.extra_chrome_categories = 'cc,blink'
+    self.RunPageTest(self.blink_page_test, 'file://lifecycle-methods.html')
+    self.assertIn('trace.html', self.test_result['outputArtifacts'])
 
 
 # pylint: disable=protected-access

tools/perf/contrib/cluster_telemetry/screenshot_unittest.py

@@ -3,41 +3,27 @@
 # found in the LICENSE file.
 
 import os
-import shutil
-import tempfile
 
 from telemetry import decorators
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
+from telemetry.testing import legacy_page_test_case
 from telemetry.util import image_util
 from contrib.cluster_telemetry import screenshot
 
-class ScreenshotUnitTest(page_test_test_case.PageTestTestCase):
-
-  def setUp(self):
-    self._png_outdir = tempfile.mkdtemp('_png_test')
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=self._png_outdir)
-
-  def tearDown(self):
-    shutil.rmtree(self._png_outdir)
 
+class ScreenshotUnitTest(legacy_page_test_case.LegacyPageTestCase):
   @decorators.Enabled('linux')
   def testScreenshot(self):
     # Screenshots for Cluster Telemetry purposes currently only supported on
     # Linux platform.
-    story_set = self.CreateStorySetFromFileInUnittestDataDir(
-      'screenshot_test.html')
-    measurement = screenshot.Screenshot(self._png_outdir)
-    self.RunMeasurement(measurement, story_set, run_options=self._options)
+    screenshot_test = screenshot.Screenshot(self.options.output_dir)
+    self.RunPageTest(screenshot_test, 'file://screenshot_test.html')
 
-    path = os.path.join(
-        self._png_outdir, story_set.stories[0].file_safe_name + '.png')
-    self.assertTrue(os.path.exists(path))
-    self.assertTrue(os.path.isfile(path))
-    self.assertTrue(os.access(path, os.R_OK))
+    filepath = os.path.join(self.options.output_dir, 'screenshot_test.png')
+    self.assertTrue(os.path.exists(filepath))
+    self.assertTrue(os.path.isfile(filepath))
+    self.assertTrue(os.access(filepath, os.R_OK))
 
-    image = image_util.FromPngFile(path)
+    image = image_util.FromPngFile(filepath)
     screenshot_pixels = image_util.Pixels(image)
     special_colored_pixel = bytearray([217, 115, 43])
     self.assertTrue(special_colored_pixel in screenshot_pixels)

tools/perf/measurements/multipage_skpicture_printer_unittest.py

@@ -2,30 +2,17 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import shutil
-import tempfile
-
 from telemetry import decorators
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
+from telemetry.testing import legacy_page_test_case
 
 from measurements import multipage_skpicture_printer
 
 
-class MultipageSkpicturePrinterUnitTest(page_test_test_case.PageTestTestCase):
-
-  def setUp(self):
-    self._mskp_outdir = tempfile.mkdtemp('_mskp_test')
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=self._mskp_outdir)
-
-  def tearDown(self):
-    shutil.rmtree(self._mskp_outdir)
-
+class MultipageSkpicturePrinterUnitTest(
+    legacy_page_test_case.LegacyPageTestCase):
   # Picture printing is not supported on all platforms.
   @decorators.Disabled('android', 'chromeos')
   def testSkpicturePrinter(self):
-    story_set = self.CreateStorySetFromFileInUnittestDataDir('blank.html')
-    measurement = multipage_skpicture_printer.MultipageSkpicturePrinter(
-        self._mskp_outdir)
-    self.RunMeasurement(measurement, story_set, run_options=self._options)
+    page_test = multipage_skpicture_printer.MultipageSkpicturePrinter(
+        self.options.output_dir)
+    self.RunPageTest(page_test, 'file://blank.html')

tools/perf/measurements/rasterize_and_record_micro_unittest.py

@@ -2,20 +2,13 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import logging
-import shutil
-import tempfile
-
 from telemetry import decorators
-from telemetry.page import legacy_page_test
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
-from telemetry.util import wpr_modes
+from telemetry.testing import legacy_page_test_case
 
 from measurements import rasterize_and_record_micro
 
 
-class RasterizeAndRecordMicroUnitTest(page_test_test_case.PageTestTestCase):
+class RasterizeAndRecordMicroUnitTest(legacy_page_test_case.LegacyPageTestCase):
   """Smoke test for rasterize_and_record_micro measurement
 
      Runs rasterize_and_record_micro measurement on a simple page and verifies
@@ -23,92 +16,33 @@ class RasterizeAndRecordMicroUnitTest(page_test_test_case.PageTestTestCase):
      i.e. it only checks if the metrics are present and non-zero.
   """
 
-  def setUp(self):
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=tempfile.mkdtemp())
-    self._options.browser_options.wpr_mode = wpr_modes.WPR_OFF
-
-  def tearDown(self):
-    shutil.rmtree(self._options.output_dir)
-
   @decorators.Disabled('win', 'chromeos', 'linux')
   def testRasterizeAndRecordMicro(self):
-    story_set = self.CreateStorySetFromFileInUnittestDataDir('blank.html')
-    measurement = rasterize_and_record_micro.RasterizeAndRecordMicro(
+    pate_test = rasterize_and_record_micro.RasterizeAndRecordMicro(
         rasterize_repeat=1, record_repeat=1, start_wait_time=0.0,
         report_detailed_results=True)
-    try:
-      results = self.RunMeasurement(
-          measurement, story_set, run_options=self._options)
-    except legacy_page_test.TestNotSupportedOnPlatformError as failure:
-      logging.warning(str(failure))
-      return
-    self.assertFalse(results.had_failures)
-
-    rasterize_time = results.FindAllPageSpecificValuesNamed('rasterize_time')
-    self.assertEquals(len(rasterize_time), 1)
-    self.assertGreater(rasterize_time[0].value, 0)
-
-    record_time = results.FindAllPageSpecificValuesNamed('record_time')
-    self.assertEquals(len(record_time), 1)
-    self.assertGreater(record_time[0].value, 0)
-
-    rasterized_pixels = results.FindAllPageSpecificValuesNamed(
-        'pixels_rasterized')
-    self.assertEquals(len(rasterized_pixels), 1)
-    self.assertGreater(rasterized_pixels[0].value, 0)
-
-    recorded_pixels = results.FindAllPageSpecificValuesNamed('pixels_recorded')
-    self.assertEquals(len(recorded_pixels), 1)
-    self.assertGreater(recorded_pixels[0].value, 0)
-
-    pixels_rasterized_with_non_solid_color = \
-        results.FindAllPageSpecificValuesNamed(
-            'pixels_rasterized_with_non_solid_color')
-    self.assertEquals(len(pixels_rasterized_with_non_solid_color), 1)
-    self.assertGreater(
-        pixels_rasterized_with_non_solid_color[0].value, 0)
-
-    pixels_rasterized_as_opaque = \
-        results.FindAllPageSpecificValuesNamed('pixels_rasterized_as_opaque')
-    self.assertEquals(len(pixels_rasterized_as_opaque), 1)
-    self.assertGreater(
-        pixels_rasterized_as_opaque[0].value, 0)
-
-    total_layers = results.FindAllPageSpecificValuesNamed('total_layers')
-    self.assertEquals(len(total_layers), 1)
-    self.assertGreater(total_layers[0].value, 0)
-
-    total_picture_layers = \
-        results.FindAllPageSpecificValuesNamed('total_picture_layers')
-    self.assertEquals(len(total_picture_layers), 1)
-    self.assertGreater(total_picture_layers[0].value, 0)
-
-    total_picture_layers_with_no_content = \
-        results.FindAllPageSpecificValuesNamed(
-            'total_picture_layers_with_no_content')
-    self.assertEquals(len(total_picture_layers_with_no_content), 1)
-    self.assertGreater(
-        total_picture_layers_with_no_content[0].value, 0)
-
-    total_picture_layers_off_screen = \
-        results.FindAllPageSpecificValuesNamed(
-            'total_picture_layers_off_screen')
-    self.assertEquals(len(total_picture_layers_off_screen), 1)
-    self.assertEqual(
-        total_picture_layers_off_screen[0].value, 0)
-
-    painter_memory_usage = results.FindAllPageSpecificValuesNamed(
-        'painter_memory_usage')
-    self.assertEquals(len(painter_memory_usage), 1)
-    self.assertGreater(painter_memory_usage[0].value, 0)
-
-    paint_op_memory_usage = results.FindAllPageSpecificValuesNamed(
-        'paint_op_memory_usage')
-    self.assertEquals(len(paint_op_memory_usage), 1)
-    self.assertGreater(paint_op_memory_usage[0].value, 0)
-
-    paint_op_count = results.FindAllPageSpecificValuesNamed(
-        'paint_op_count')
-    self.assertEquals(len(paint_op_count), 1)
-    self.assertGreater(paint_op_count[0].value, 0)
+    measurements = self.RunPageTest(pate_test, 'file://blank.html')
+
+    # For these measurements, a single positive scalar value is expected.
+    expected_positve_scalar = [
+        'rasterize_time',
+        'record_time',
+        'pixels_rasterized',
+        'pixels_recorded',
+        'pixels_rasterized_with_non_solid_color',
+        'pixels_rasterized_as_opaque',
+        'total_layers',
+        'total_picture_layers',
+        'total_picture_layers_with_no_content',
+        'painter_memory_usage',
+        'paint_op_memory_usage',
+        'paint_op_count',
+    ]
+    for name in expected_positve_scalar:
+      samples = measurements[name]['samples']
+      self.assertEqual(len(samples), 1)
+      self.assertGreater(samples[0], 0)
+
+    samples = measurements['total_picture_layers_off_screen']['samples']
+    self.assertEqual(len(samples), 1)
+    self.assertEqual(samples[0], 0)

tools/perf/measurements/skpicture_printer_unittest.py

@@ -2,35 +2,18 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-import shutil
-import tempfile
-
 from telemetry import decorators
-from telemetry.testing import options_for_unittests
-from telemetry.testing import page_test_test_case
+from telemetry.testing import legacy_page_test_case
 
 from measurements import skpicture_printer
 
 
-class SkpicturePrinterUnitTest(page_test_test_case.PageTestTestCase):
-
-  def setUp(self):
-    self._skp_outdir = tempfile.mkdtemp('_skp_test')
-    self._options = options_for_unittests.GetRunOptions(
-        output_dir=self._skp_outdir)
-
-  def tearDown(self):
-    shutil.rmtree(self._skp_outdir)
-
+class SkpicturePrinterUnitTest(legacy_page_test_case.LegacyPageTestCase):
   # Picture printing is not supported on all platforms.
   @decorators.Disabled('android', 'chromeos')
   def testSkpicturePrinter(self):
-    story_set = self.CreateStorySetFromFileInUnittestDataDir('blank.html')
-    measurement = skpicture_printer.SkpicturePrinter(self._skp_outdir)
-    results = self.RunMeasurement(
-        measurement, story_set, run_options=self._options)
-
-    saved_picture_count = results.FindAllPageSpecificValuesNamed(
-        'saved_picture_count')
+    page_test = skpicture_printer.SkpicturePrinter(self.options.output_dir)
+    measurements = self.RunPageTest(page_test, 'file://blank.html')
+    saved_picture_count = measurements['saved_picture_count']['samples']
     self.assertEquals(len(saved_picture_count), 1)
-    self.assertGreater(saved_picture_count[0].value, 0)
+    self.assertGreater(saved_picture_count[0], 0)