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.
4import os
5import unittest
6
7from telemetry import value
8from telemetry.page import page_set
9from telemetry.value import list_of_scalar_values
10from telemetry.value import none_values
11
12
13class 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
24class 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')
170