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