src/tools/telemetry/telemetry/value/list_of_scalar_values_unittest.py

   1 # Copyright 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4 import os
   5 import unittest
   6
   7 from telemetry import value
   8 from telemetry.page import page_set
   9 from telemetry.value import list_of_scalar_values
  10 from telemetry.value import none_values
  11
  12
  13 class TestBase(unittest.TestCase):
  14   def setUp(self):
  15     self.page_set = page_set.PageSet(file_path=os.path.dirname(__file__))
  16     self.page_set.AddPageWithDefaultRunNavigate("http://www.bar.com/")
  17     self.page_set.AddPageWithDefaultRunNavigate("http://www.baz.com/")
  18     self.page_set.AddPageWithDefaultRunNavigate("http://www.foo.com/")
  19
  20   @property
  21   def pages(self):
  22     return self.page_set.pages
  23
  24 class ValueTest(TestBase):
  25   def testListSamePageMergingWithSamePageConcatenatePolicy(self):
  26     page0 = self.pages[0]
  27     v0 = list_of_scalar_values.ListOfScalarValues(
  28         page0, 'x', 'unit',
  29         [1,2], same_page_merge_policy=value.CONCATENATE)
  30     v1 = list_of_scalar_values.ListOfScalarValues(
  31         page0, 'x', 'unit',
  32         [3,4], same_page_merge_policy=value.CONCATENATE)
  33     self.assertTrue(v1.IsMergableWith(v0))
  34
  35     vM = (list_of_scalar_values.ListOfScalarValues.
  36           MergeLikeValuesFromSamePage([v0, v1]))
  37     self.assertEquals(page0, vM.page)
  38     self.assertEquals('x', vM.name)
  39     self.assertEquals('unit', vM.units)
  40     self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy)
  41     self.assertEquals(True, vM.important)
  42     self.assertEquals([1, 2, 3, 4], vM.values)
  43
  44   def testListSamePageMergingWithPickFirstPolicy(self):
  45     page0 = self.pages[0]
  46     v0 = list_of_scalar_values.ListOfScalarValues(
  47         page0, 'x', 'unit',
  48         [1,2], same_page_merge_policy=value.PICK_FIRST)
  49     v1 = list_of_scalar_values.ListOfScalarValues(
  50         page0, 'x', 'unit',
  51         [3,4], same_page_merge_policy=value.PICK_FIRST)
  52     self.assertTrue(v1.IsMergableWith(v0))
  53
  54     vM = (list_of_scalar_values.ListOfScalarValues.
  55           MergeLikeValuesFromSamePage([v0, v1]))
  56     self.assertEquals(page0, vM.page)
  57     self.assertEquals('x', vM.name)
  58     self.assertEquals('unit', vM.units)
  59     self.assertEquals(value.PICK_FIRST, vM.same_page_merge_policy)
  60     self.assertEquals(True, vM.important)
  61     self.assertEquals([1, 2], vM.values)
  62
  63   def testListDifferentPageMerging(self):
  64     page0 = self.pages[0]
  65     page1 = self.pages[1]
  66     v0 = list_of_scalar_values.ListOfScalarValues(
  67         page0, 'x', 'unit',
  68         [1, 2], same_page_merge_policy=value.CONCATENATE)
  69     v1 = list_of_scalar_values.ListOfScalarValues(
  70         page1, 'x', 'unit',
  71         [3, 4], same_page_merge_policy=value.CONCATENATE)
  72     self.assertTrue(v1.IsMergableWith(v0))
  73
  74     vM = (list_of_scalar_values.ListOfScalarValues.
  75           MergeLikeValuesFromDifferentPages([v0, v1]))
  76     self.assertEquals(None, vM.page)
  77     self.assertEquals('x', vM.name)
  78     self.assertEquals('unit', vM.units)
  79     self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy)
  80     self.assertEquals(True, vM.important)
  81     self.assertEquals([1, 2, 3, 4], vM.values)
  82
  83   def testListWithNoneValueMerging(self):
  84     page0 = self.pages[0]
  85     v0 = list_of_scalar_values.ListOfScalarValues(
  86         page0, 'x', 'unit',
  87         [1, 2], same_page_merge_policy=value.CONCATENATE)
  88     v1 = list_of_scalar_values.ListOfScalarValues(
  89         page0, 'x', 'unit',
  90         None, same_page_merge_policy=value.CONCATENATE, none_value_reason='n')
  91     self.assertTrue(v1.IsMergableWith(v0))
  92
  93     vM = (list_of_scalar_values.ListOfScalarValues.
  94           MergeLikeValuesFromSamePage([v0, v1]))
  95     self.assertEquals(None, vM.values)
  96     self.assertEquals(none_values.MERGE_FAILURE_REASON,
  97                       vM.none_value_reason)
  98
  99   def testListWithNoneValueMustHaveNoneReason(self):
 100     page0 = self.pages[0]
 101     self.assertRaises(none_values.NoneValueMissingReason,
 102                       lambda: list_of_scalar_values.ListOfScalarValues(
 103                           page0, 'x', 'unit', None))
 104
 105   def testListWithNoneReasonMustHaveNoneValue(self):
 106     page0 = self.pages[0]
 107     self.assertRaises(none_values.ValueMustHaveNoneValue,
 108                       lambda: list_of_scalar_values.ListOfScalarValues(
 109                           page0, 'x', 'unit', [1, 2],
 110                           none_value_reason='n'))
 111
 112   def testAsDict(self):
 113     v = list_of_scalar_values.ListOfScalarValues(
 114         None, 'x', 'unit', [1, 2],
 115         same_page_merge_policy=value.PICK_FIRST, important=False)
 116     d = v.AsDictWithoutBaseClassEntries()
 117
 118     self.assertEquals(d, {
 119           'values': [1, 2]
 120         })
 121
 122   def testNoneValueAsDict(self):
 123     v = list_of_scalar_values.ListOfScalarValues(
 124         None, 'x', 'unit', None, same_page_merge_policy=value.PICK_FIRST,
 125         important=False, none_value_reason='n')
 126     d = v.AsDictWithoutBaseClassEntries()
 127
 128     self.assertEquals(d, {
 129           'values': None,
 130           'none_value_reason': 'n'
 131         })
 132
 133   def testFromDictInts(self):
 134     d = {
 135       'type': 'list_of_scalar_values',
 136       'name': 'x',
 137       'units': 'unit',
 138       'values': [1, 2]
 139     }
 140     v = value.Value.FromDict(d, {})
 141
 142     self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues))
 143     self.assertEquals(v.values, [1, 2])
 144
 145   def testFromDictFloats(self):
 146     d = {
 147       'type': 'list_of_scalar_values',
 148       'name': 'x',
 149       'units': 'unit',
 150       'values': [1.3, 2.7]
 151     }
 152     v = value.Value.FromDict(d, {})
 153
 154     self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues))
 155     self.assertEquals(v.values, [1.3, 2.7])
 156
 157   def testFromDictNoneValue(self):
 158     d = {
 159       'type': 'list_of_scalar_values',
 160       'name': 'x',
 161       'units': 'unit',
 162       'values': None,
 163       'none_value_reason': 'n'
 164     }
 165     v = value.Value.FromDict(d, {})
 166
 167     self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues))
 168     self.assertEquals(v.values, None)
 169     self.assertEquals(v.none_value_reason, 'n')