Added support for improvement_direction to relevant values, which is propogated to chartjson.

tools/telemetry/telemetry/results/json_output_formatter_unittest.py

 # Copyright 2014 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.
 import json
 import os
 import shutil
 import StringIO
 import unittest
 import tempfile
 
 from telemetry import benchmark
 from telemetry import page as page_module
 from telemetry.page import page_set
 from telemetry.results import json_output_formatter
 from telemetry.results import page_test_results
+from telemetry.value import improvement_direction
 from telemetry.value import scalar
 from telemetry.value import trace
 from telemetry.timeline import trace_data
 
 
 def _MakePageSet():
   ps = page_set.PageSet(file_path=os.path.dirname(__file__))
   ps.AddUserStory(page_module.Page('http://www.foo.com/', ps, ps.base_dir))
   ps.AddUserStory(page_module.Page('http://www.bar.com/', ps, ps.base_dir))
   return ps
@@ skipping 11 matching lines @@
     self._formatter = json_output_formatter.JsonOutputFormatter(
         self._output,
         benchmark.BenchmarkMetadata('benchmark_name'))
 
   def testOutputAndParse(self):
     results = page_test_results.PageTestResults()
 
     self._output.truncate(0)
 
     results.WillRunPage(self._page_set[0])
-    v0 = scalar.ScalarValue(results.current_page, 'foo', 'seconds', 3)
+    v0 = scalar.ScalarValue(results.current_page, 'foo', 'seconds', 3,
+                            improvement_direction=improvement_direction.DOWN)
     results.AddValue(v0)
     results.DidRunPage(self._page_set[0])
 
     self._formatter.Format(results)
     json.loads(self._output.getvalue())
 
   def testAsDictBaseKeys(self):
     results = page_test_results.PageTestResults()
     d = json_output_formatter.ResultsAsDict(results,
         self._formatter.benchmark_metadata)
 
     self.assertEquals(d['format_version'], '0.2')
     self.assertEquals(d['benchmark_name'], 'benchmark_name')
 
   def testAsDictWithOnePage(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self._page_set[0])
-    v0 = scalar.ScalarValue(results.current_page, 'foo', 'seconds', 3)
+    v0 = scalar.ScalarValue(results.current_page, 'foo', 'seconds', 3,
+                            improvement_direction=improvement_direction.DOWN)
     results.AddValue(v0)
     results.DidRunPage(self._page_set[0])
 
     d = json_output_formatter.ResultsAsDict(results,
         self._formatter.benchmark_metadata)
 
     self.assertTrue(_HasPage(d['pages'], self._page_set[0]))
     self.assertTrue(_HasValueNamed(d['per_page_values'], 'foo'))
 
   def testAsDictWithTraceValue(self):
@@ skipping 17 matching lines @@
       self.assertTrue(output_trace_path.startswith(tempdir))
       self.assertTrue(os.path.exists(output_trace_path))
     finally:
       shutil.rmtree(tempdir)
 
 
 
   def testAsDictWithTwoPages(self):
     results = page_test_results.PageTestResults()
     results.WillRunPage(self._page_set[0])
-    v0 = scalar.ScalarValue(results.current_page, 'foo', 'seconds', 3)
+    v0 = scalar.ScalarValue(results.current_page, 'foo', 'seconds', 3,
+                            improvement_direction=improvement_direction.DOWN)
     results.AddValue(v0)
     results.DidRunPage(self._page_set[0])
 
     results.WillRunPage(self._page_set[1])
-    v1 = scalar.ScalarValue(results.current_page, 'bar', 'seconds', 4)
+    v1 = scalar.ScalarValue(results.current_page, 'bar', 'seconds', 4,
+                            improvement_direction=improvement_direction.DOWN)
     results.AddValue(v1)
     results.DidRunPage(self._page_set[1])
 
     d = json_output_formatter.ResultsAsDict(results,
         self._formatter.benchmark_metadata)
 
     self.assertTrue(_HasPage(d['pages'], self._page_set[0]))
     self.assertTrue(_HasPage(d['pages'], self._page_set[1]))
     self.assertTrue(_HasValueNamed(d['per_page_values'], 'foo'))
     self.assertTrue(_HasValueNamed(d['per_page_values'], 'bar'))
 
   def testAsDictWithSummaryValueOnly(self):
     results = page_test_results.PageTestResults()
-    v = scalar.ScalarValue(None, 'baz', 'seconds', 5)
+    v = scalar.ScalarValue(None, 'baz', 'seconds', 5,
+                           improvement_direction=improvement_direction.DOWN)
     results.AddSummaryValue(v)
 
     d = json_output_formatter.ResultsAsDict(results,
         self._formatter.benchmark_metadata)
 
     self.assertFalse(d['pages'])
     self.assertTrue(_HasValueNamed(d['summary_values'], 'baz'))