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 story | 7 from telemetry import story |
8 from telemetry import page as page_module | 8 from telemetry import page as page_module |
9 from telemetry import value | 9 from telemetry import value |
| 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 StatisticComputationTest(unittest.TestCase): | 15 class StatisticComputationTest(unittest.TestCase): |
15 def testVariance(self): | 16 def testVariance(self): |
16 self.assertAlmostEqual( | 17 self.assertAlmostEqual( |
17 list_of_scalar_values.Variance([]), 0) | 18 list_of_scalar_values.Variance([]), 0) |
18 self.assertAlmostEqual( | 19 self.assertAlmostEqual( |
19 list_of_scalar_values.Variance([3]), 0) | 20 list_of_scalar_values.Variance([3]), 0) |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
64 | 65 |
65 @property | 66 @property |
66 def pages(self): | 67 def pages(self): |
67 return self.story_set.stories | 68 return self.story_set.stories |
68 | 69 |
69 class ValueTest(TestBase): | 70 class ValueTest(TestBase): |
70 def testListSamePageMergingWithSamePageConcatenatePolicy(self): | 71 def testListSamePageMergingWithSamePageConcatenatePolicy(self): |
71 page0 = self.pages[0] | 72 page0 = self.pages[0] |
72 v0 = list_of_scalar_values.ListOfScalarValues( | 73 v0 = list_of_scalar_values.ListOfScalarValues( |
73 page0, 'x', 'unit', | 74 page0, 'x', 'unit', |
74 [10, 9, 9, 7], same_page_merge_policy=value.CONCATENATE) | 75 [10, 9, 9, 7], same_page_merge_policy=value.CONCATENATE, |
| 76 improvement_direction=improvement_direction.DOWN) |
75 v1 = list_of_scalar_values.ListOfScalarValues( | 77 v1 = list_of_scalar_values.ListOfScalarValues( |
76 page0, 'x', 'unit', | 78 page0, 'x', 'unit', |
77 [300, 302, 303, 304], same_page_merge_policy=value.CONCATENATE) | 79 [300, 302, 303, 304], same_page_merge_policy=value.CONCATENATE, |
| 80 improvement_direction=improvement_direction.DOWN) |
78 self.assertTrue(v1.IsMergableWith(v0)) | 81 self.assertTrue(v1.IsMergableWith(v0)) |
79 | 82 |
80 vM = (list_of_scalar_values.ListOfScalarValues. | 83 vM = (list_of_scalar_values.ListOfScalarValues. |
81 MergeLikeValuesFromSamePage([v0, v1])) | 84 MergeLikeValuesFromSamePage([v0, v1])) |
82 self.assertEquals(page0, vM.page) | 85 self.assertEquals(page0, vM.page) |
83 self.assertEquals('x', vM.name) | 86 self.assertEquals('x', vM.name) |
84 self.assertEquals('unit', vM.units) | 87 self.assertEquals('unit', vM.units) |
85 self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy) | 88 self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy) |
86 self.assertEquals(True, vM.important) | 89 self.assertEquals(True, vM.important) |
87 self.assertEquals([10, 9, 9, 7, 300, 302, 303, 304], vM.values) | 90 self.assertEquals([10, 9, 9, 7, 300, 302, 303, 304], vM.values) |
88 # SQRT((19/12 * 3 + 35/12 * 3)/6) = 1.5 | 91 # SQRT((19/12 * 3 + 35/12 * 3)/6) = 1.5 |
89 self.assertAlmostEqual(1.5, vM.std) | 92 self.assertAlmostEqual(1.5, vM.std) |
| 93 self.assertEquals(improvement_direction.DOWN, vM.improvement_direction) |
90 | 94 |
91 def testListSamePageMergingWithPickFirstPolicy(self): | 95 def testListSamePageMergingWithPickFirstPolicy(self): |
92 page0 = self.pages[0] | 96 page0 = self.pages[0] |
93 v0 = list_of_scalar_values.ListOfScalarValues( | 97 v0 = list_of_scalar_values.ListOfScalarValues( |
94 page0, 'x', 'unit', | 98 page0, 'x', 'unit', |
95 [1, 2], same_page_merge_policy=value.PICK_FIRST) | 99 [1, 2], same_page_merge_policy=value.PICK_FIRST, |
| 100 improvement_direction=improvement_direction.UP) |
96 v1 = list_of_scalar_values.ListOfScalarValues( | 101 v1 = list_of_scalar_values.ListOfScalarValues( |
97 page0, 'x', 'unit', | 102 page0, 'x', 'unit', |
98 [3, 4], same_page_merge_policy=value.PICK_FIRST) | 103 [3, 4], same_page_merge_policy=value.PICK_FIRST, |
| 104 improvement_direction=improvement_direction.UP) |
99 self.assertTrue(v1.IsMergableWith(v0)) | 105 self.assertTrue(v1.IsMergableWith(v0)) |
100 | 106 |
101 vM = (list_of_scalar_values.ListOfScalarValues. | 107 vM = (list_of_scalar_values.ListOfScalarValues. |
102 MergeLikeValuesFromSamePage([v0, v1])) | 108 MergeLikeValuesFromSamePage([v0, v1])) |
103 self.assertEquals(page0, vM.page) | 109 self.assertEquals(page0, vM.page) |
104 self.assertEquals('x', vM.name) | 110 self.assertEquals('x', vM.name) |
105 self.assertEquals('unit', vM.units) | 111 self.assertEquals('unit', vM.units) |
106 self.assertEquals(value.PICK_FIRST, vM.same_page_merge_policy) | 112 self.assertEquals(value.PICK_FIRST, vM.same_page_merge_policy) |
107 self.assertEquals(True, vM.important) | 113 self.assertEquals(True, vM.important) |
108 self.assertEquals([1, 2], vM.values) | 114 self.assertEquals([1, 2], vM.values) |
| 115 self.assertEquals(improvement_direction.UP, vM.improvement_direction) |
109 | 116 |
110 def testListDifferentPageMerging(self): | 117 def testListDifferentPageMerging(self): |
111 page0 = self.pages[0] | 118 page0 = self.pages[0] |
112 page1 = self.pages[1] | 119 page1 = self.pages[1] |
113 v0 = list_of_scalar_values.ListOfScalarValues( | 120 v0 = list_of_scalar_values.ListOfScalarValues( |
114 page0, 'x', 'unit', | 121 page0, 'x', 'unit', |
115 [1, 2], same_page_merge_policy=value.CONCATENATE) | 122 [1, 2], same_page_merge_policy=value.CONCATENATE, |
| 123 improvement_direction=improvement_direction.DOWN) |
116 v1 = list_of_scalar_values.ListOfScalarValues( | 124 v1 = list_of_scalar_values.ListOfScalarValues( |
117 page1, 'x', 'unit', | 125 page1, 'x', 'unit', |
118 [3, 4], same_page_merge_policy=value.CONCATENATE) | 126 [3, 4], same_page_merge_policy=value.CONCATENATE, |
| 127 improvement_direction=improvement_direction.DOWN) |
119 self.assertTrue(v1.IsMergableWith(v0)) | 128 self.assertTrue(v1.IsMergableWith(v0)) |
120 | 129 |
121 vM = (list_of_scalar_values.ListOfScalarValues. | 130 vM = (list_of_scalar_values.ListOfScalarValues. |
122 MergeLikeValuesFromDifferentPages([v0, v1])) | 131 MergeLikeValuesFromDifferentPages([v0, v1])) |
123 self.assertEquals(None, vM.page) | 132 self.assertEquals(None, vM.page) |
124 self.assertEquals('x', vM.name) | 133 self.assertEquals('x', vM.name) |
125 self.assertEquals('unit', vM.units) | 134 self.assertEquals('unit', vM.units) |
126 self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy) | 135 self.assertEquals(value.CONCATENATE, vM.same_page_merge_policy) |
127 self.assertEquals(True, vM.important) | 136 self.assertEquals(True, vM.important) |
128 self.assertEquals([1, 2, 3, 4], vM.values) | 137 self.assertEquals([1, 2, 3, 4], vM.values) |
| 138 self.assertEquals(improvement_direction.DOWN, vM.improvement_direction) |
129 | 139 |
130 def testListWithNoneValueMerging(self): | 140 def testListWithNoneValueMerging(self): |
131 page0 = self.pages[0] | 141 page0 = self.pages[0] |
132 v0 = list_of_scalar_values.ListOfScalarValues( | 142 v0 = list_of_scalar_values.ListOfScalarValues( |
133 page0, 'x', 'unit', | 143 page0, 'x', 'unit', |
134 [1, 2], same_page_merge_policy=value.CONCATENATE) | 144 [1, 2], same_page_merge_policy=value.CONCATENATE, |
| 145 improvement_direction=improvement_direction.UP) |
135 v1 = list_of_scalar_values.ListOfScalarValues( | 146 v1 = list_of_scalar_values.ListOfScalarValues( |
136 page0, 'x', 'unit', | 147 page0, 'x', 'unit', |
137 None, same_page_merge_policy=value.CONCATENATE, none_value_reason='n') | 148 None, same_page_merge_policy=value.CONCATENATE, none_value_reason='n', |
| 149 improvement_direction=improvement_direction.UP) |
138 self.assertTrue(v1.IsMergableWith(v0)) | 150 self.assertTrue(v1.IsMergableWith(v0)) |
139 | 151 |
140 vM = (list_of_scalar_values.ListOfScalarValues. | 152 vM = (list_of_scalar_values.ListOfScalarValues. |
141 MergeLikeValuesFromSamePage([v0, v1])) | 153 MergeLikeValuesFromSamePage([v0, v1])) |
142 self.assertEquals(None, vM.values) | 154 self.assertEquals(None, vM.values) |
143 self.assertEquals(none_values.MERGE_FAILURE_REASON, | 155 self.assertEquals(none_values.MERGE_FAILURE_REASON, |
144 vM.none_value_reason) | 156 vM.none_value_reason) |
| 157 self.assertEquals(improvement_direction.UP, vM.improvement_direction) |
145 | 158 |
146 def testListWithNoneValueMustHaveNoneReason(self): | 159 def testListWithNoneValueMustHaveNoneReason(self): |
147 page0 = self.pages[0] | 160 page0 = self.pages[0] |
148 self.assertRaises(none_values.NoneValueMissingReason, | 161 self.assertRaises(none_values.NoneValueMissingReason, |
149 lambda: list_of_scalar_values.ListOfScalarValues( | 162 lambda: list_of_scalar_values.ListOfScalarValues( |
150 page0, 'x', 'unit', None)) | 163 page0, 'x', 'unit', None, |
| 164 improvement_direction=improvement_direction.DOWN)) |
151 | 165 |
152 def testListWithNoneReasonMustHaveNoneValue(self): | 166 def testListWithNoneReasonMustHaveNoneValue(self): |
153 page0 = self.pages[0] | 167 page0 = self.pages[0] |
154 self.assertRaises(none_values.ValueMustHaveNoneValue, | 168 self.assertRaises(none_values.ValueMustHaveNoneValue, |
155 lambda: list_of_scalar_values.ListOfScalarValues( | 169 lambda: list_of_scalar_values.ListOfScalarValues( |
156 page0, 'x', 'unit', [1, 2], | 170 page0, 'x', 'unit', [1, 2], |
157 none_value_reason='n')) | 171 none_value_reason='n', |
| 172 improvement_direction=improvement_direction.UP)) |
158 | 173 |
159 def testAsDict(self): | 174 def testAsDict(self): |
160 v = list_of_scalar_values.ListOfScalarValues( | 175 v = list_of_scalar_values.ListOfScalarValues( |
161 None, 'x', 'unit', [1, 2], | 176 None, 'x', 'unit', [1, 2], |
162 same_page_merge_policy=value.PICK_FIRST, important=False) | 177 same_page_merge_policy=value.PICK_FIRST, important=False, |
| 178 improvement_direction=improvement_direction.DOWN) |
163 d = v.AsDictWithoutBaseClassEntries() | 179 d = v.AsDictWithoutBaseClassEntries() |
164 | 180 |
165 self.assertEquals(d['values'], [1, 2]) | 181 self.assertEquals(d['values'], [1, 2]) |
166 self.assertAlmostEqual(d['std'], 0.7071, places=4) | 182 self.assertAlmostEqual(d['std'], 0.7071, places=4) |
167 | 183 |
168 def testMergedValueAsDict(self): | 184 def testMergedValueAsDict(self): |
169 page0 = self.pages[0] | 185 page0 = self.pages[0] |
170 v0 = list_of_scalar_values.ListOfScalarValues( | 186 v0 = list_of_scalar_values.ListOfScalarValues( |
171 page0, 'x', 'unit', | 187 page0, 'x', 'unit', |
172 [10, 9, 9, 7], same_page_merge_policy=value.CONCATENATE) | 188 [10, 9, 9, 7], same_page_merge_policy=value.CONCATENATE, |
| 189 improvement_direction=improvement_direction.DOWN) |
173 v1 = list_of_scalar_values.ListOfScalarValues( | 190 v1 = list_of_scalar_values.ListOfScalarValues( |
174 page0, 'x', 'unit', | 191 page0, 'x', 'unit', |
175 [300, 302, 303, 304], same_page_merge_policy=value.CONCATENATE) | 192 [300, 302, 303, 304], same_page_merge_policy=value.CONCATENATE, |
| 193 improvement_direction=improvement_direction.DOWN) |
176 self.assertTrue(v1.IsMergableWith(v0)) | 194 self.assertTrue(v1.IsMergableWith(v0)) |
177 | 195 |
178 vM = (list_of_scalar_values.ListOfScalarValues. | 196 vM = (list_of_scalar_values.ListOfScalarValues. |
179 MergeLikeValuesFromSamePage([v0, v1])) | 197 MergeLikeValuesFromSamePage([v0, v1])) |
180 d = vM.AsDict() | 198 d = vM.AsDict() |
181 self.assertEquals(d['values'], [10, 9, 9, 7, 300, 302, 303, 304]) | 199 self.assertEquals(d['values'], [10, 9, 9, 7, 300, 302, 303, 304]) |
182 # SQRT((19/12 * 3 + 35/12 * 3)/6) | 200 # SQRT((19/12 * 3 + 35/12 * 3)/6) |
183 self.assertAlmostEqual(d['std'], 1.5) | 201 self.assertAlmostEqual(d['std'], 1.5) |
184 | 202 |
185 | 203 |
186 def testNoneValueAsDict(self): | 204 def testNoneValueAsDict(self): |
187 v = list_of_scalar_values.ListOfScalarValues( | 205 v = list_of_scalar_values.ListOfScalarValues( |
188 None, 'x', 'unit', None, same_page_merge_policy=value.PICK_FIRST, | 206 None, 'x', 'unit', None, same_page_merge_policy=value.PICK_FIRST, |
189 important=False, none_value_reason='n') | 207 important=False, none_value_reason='n', |
| 208 improvement_direction=improvement_direction.UP) |
190 d = v.AsDictWithoutBaseClassEntries() | 209 d = v.AsDictWithoutBaseClassEntries() |
191 | 210 |
192 self.assertEquals(d, { | 211 self.assertEquals(d, { |
193 'values': None, | 212 'values': None, |
194 'none_value_reason': 'n', | 213 'none_value_reason': 'n', |
195 'std': None | 214 'std': None |
196 }) | 215 }) |
197 | 216 |
198 def testFromDictInts(self): | 217 def testFromDictInts(self): |
199 d = { | 218 d = { |
200 'type': 'list_of_scalar_values', | 219 'type': 'list_of_scalar_values', |
201 'name': 'x', | 220 'name': 'x', |
202 'units': 'unit', | 221 'units': 'unit', |
203 'values': [1, 2], | 222 'values': [1, 2], |
204 'std': 0.7071 | 223 'std': 0.7071, |
| 224 'improvement_direction': improvement_direction.DOWN |
205 } | 225 } |
206 v = value.Value.FromDict(d, {}) | 226 v = value.Value.FromDict(d, {}) |
207 | 227 |
208 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) | 228 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) |
209 self.assertEquals(v.values, [1, 2]) | 229 self.assertEquals(v.values, [1, 2]) |
210 self.assertEquals(v.std, 0.7071) | 230 self.assertEquals(v.std, 0.7071) |
| 231 self.assertEquals(improvement_direction.DOWN, v.improvement_direction) |
211 | 232 |
212 def testFromDictFloats(self): | 233 def testFromDictFloats(self): |
213 d = { | 234 d = { |
214 'type': 'list_of_scalar_values', | 235 'type': 'list_of_scalar_values', |
215 'name': 'x', | 236 'name': 'x', |
216 'units': 'unit', | 237 'units': 'unit', |
217 'values': [1.3, 2.7, 4.5, 2.1, 3.4], | 238 'values': [1.3, 2.7, 4.5, 2.1, 3.4], |
218 'std': 0.901 | 239 'std': 0.901, |
| 240 'improvement_direction': improvement_direction.UP |
219 } | 241 } |
220 v = value.Value.FromDict(d, {}) | 242 v = value.Value.FromDict(d, {}) |
221 | 243 |
222 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) | 244 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) |
223 self.assertEquals(v.values, [1.3, 2.7, 4.5, 2.1, 3.4]) | 245 self.assertEquals(v.values, [1.3, 2.7, 4.5, 2.1, 3.4]) |
224 self.assertEquals(v.std, 0.901) | 246 self.assertEquals(v.std, 0.901) |
225 | 247 |
226 def testFromDictNoneValue(self): | 248 def testFromDictNoneValue(self): |
227 d = { | 249 d = { |
228 'type': 'list_of_scalar_values', | 250 'type': 'list_of_scalar_values', |
229 'name': 'x', | 251 'name': 'x', |
230 'units': 'unit', | 252 'units': 'unit', |
231 'values': None, | 253 'values': None, |
232 'std': None, | 254 'std': None, |
233 'none_value_reason': 'n' | 255 'none_value_reason': 'n', |
| 256 'improvement_direction': improvement_direction.DOWN |
234 } | 257 } |
235 v = value.Value.FromDict(d, {}) | 258 v = value.Value.FromDict(d, {}) |
236 | 259 |
237 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) | 260 self.assertTrue(isinstance(v, list_of_scalar_values.ListOfScalarValues)) |
238 self.assertEquals(v.values, None) | 261 self.assertEquals(v.values, None) |
239 self.assertEquals(v.none_value_reason, 'n') | 262 self.assertEquals(v.none_value_reason, 'n') |
OLD | NEW |