def testSamePageMergeNonstandardKeyFunc(self): page0 = self.pages[0] page1 = self.pages[1] all_values = [scalar.ScalarValue( page0, 'x', 'units', 1, improvement_direction=improvement_direction.UP), scalar.ScalarValue( page1, 'x', 'units', 4, improvement_direction=improvement_direction.UP), scalar.ScalarValue( page0, 'y', 'units', 2, improvement_direction=improvement_direction.UP), scalar.ScalarValue( page1, 'y', 'units', 5, improvement_direction=improvement_direction.UP)] merged_values = merge_values.MergeLikeValuesFromSamePage( all_values, key_func=lambda v: v.page.name) # Sort the results so that their order is predictable for the subsequent # assertions. merged_values.sort(key=lambda x: x.page.url) self.assertEquals(2, len(merged_values)) self.assertEquals([1, 2], merged_values[0].values) self.assertEquals([4, 5], merged_values[1].values)
def testSamePageMergeBasic(self): page0 = self.pages[0] page1 = self.pages[1] all_values = [ scalar.ScalarValue(page0, 'x', 'units', 1), scalar.ScalarValue(page1, 'x', 'units', 4), scalar.ScalarValue(page0, 'x', 'units', 2), scalar.ScalarValue(page1, 'x', 'units', 5) ] merged_values = merge_values.MergeLikeValuesFromSamePage(all_values) # Sort the results so that their order is predictable for the subsequent # assertions. merged_values.sort(key=lambda x: x.page.url) self.assertEquals(2, len(merged_values)) self.assertEquals((page0, 'x'), (merged_values[0].page, merged_values[0].name)) self.assertEquals([1, 2], merged_values[0].values) self.assertEquals((page1, 'x'), (merged_values[1].page, merged_values[1].name)) self.assertEquals([4, 5], merged_values[1].values)
def testSamePageMergeWithTwoInteractionRecords(self): page0 = self.pages[0] all_values = [scalar.ScalarValue(page0, 'x', 'units', 1, tir_label='foo'), scalar.ScalarValue(page0, 'x', 'units', 4, tir_label='bar')] merged_values = merge_values.MergeLikeValuesFromSamePage(all_values) self.assertEquals(2, len(merged_values)) self.assertEquals('foo', merged_values[0].tir_label) self.assertEquals('bar', merged_values[1].tir_label)
def testSamePageMergeOneValue(self): page0 = self.pages[0] all_values = [scalar.ScalarValue(page0, 'x', 'units', 1)] # Sort the results so that their order is predictable for the subsequent # assertions. merged_values = merge_values.MergeLikeValuesFromSamePage(all_values) self.assertEquals(1, len(merged_values)) self.assertEquals(all_values[0].name, merged_values[0].name) self.assertEquals(all_values[0].units, merged_values[0].units)
def Format(self, page_test_results): values = merge_values.MergeLikeValuesFromSamePage( page_test_results.all_page_specific_values) writer = csv.writer(self.output_stream) header_value_names = self._OutputHeader(values, writer) value_groups_by_page = merge_values.GroupStably( values, lambda value: value.page.url) for values_for_page in value_groups_by_page: self._OutputValuesForPage(header_value_names, values_for_page[0].page, values_for_page, writer)
def testSamePageMergeWithInteractionRecord(self): page0 = self.pages[0] all_values = [scalar.ScalarValue( page0, 'foo-x', 'units', 1, tir_label='foo', improvement_direction=improvement_direction.UP), scalar.ScalarValue( page0, 'foo-x', 'units', 4, tir_label='foo', improvement_direction=improvement_direction.UP)] merged_values = merge_values.MergeLikeValuesFromSamePage(all_values) self.assertEquals(1, len(merged_values)) self.assertEquals('foo', merged_values[0].tir_label)
def PrintSummary(self): try: if self._output_after_every_page: return self._OutputHeader() values = merge_values.MergeLikeValuesFromSamePage( self.all_page_specific_values) value_groups_by_page = merge_values.GroupStably( values, lambda value: value.page.url) for values_for_page in value_groups_by_page: self._OutputValuesForPage(values_for_page[0].page, values_for_page) finally: super(CsvPageMeasurementResults, self).PrintSummary()
def testSamePageMergeWithSameGroupingKey(self): page0 = self.pages[0] all_values = [ scalar.ScalarValue(page0, 'x', 'units', 1, grouping_keys={'foo': 'bar'}), scalar.ScalarValue(page0, 'x', 'units', 4, grouping_keys={'foo': 'bar'}) ] merged_values = merge_values.MergeLikeValuesFromSamePage(all_values) self.assertEquals(1, len(merged_values)) self.assertEquals({'foo': 'bar'}, merged_values[0].grouping_keys)
def testSamePageMergeWithGroupingLabel(self): page0 = self.pages[0] page0.grouping_keys['label'] = 'foo' all_values = [ scalar.ScalarValue(page0, 'foo-x', 'units', 1, improvement_direction=improvement_direction.UP), scalar.ScalarValue(page0, 'foo-x', 'units', 4, improvement_direction=improvement_direction.UP) ] merged_values = merge_values.MergeLikeValuesFromSamePage(all_values) self.assertEquals(1, len(merged_values)) self.assertEquals('foo', merged_values[0].grouping_label)
def _ComputePerPageValues(self, all_page_specific_values): all_successful_page_values = all_page_specific_values # We will later need to determine how many values were originally created # for each value name, to apply a workaround meant to clean up the printf # output. num_successful_pages_for_value_name = defaultdict(int) for v in all_successful_page_values: num_successful_pages_for_value_name[v.name] += 1 # By here, due to page repeat options, all_values_from_successful_pages # contains values of the same name not only from mulitple pages, but also # from the same name. So even if, for instance, only one page ran, it may # have run twice, producing two 'x' values. # # So, get rid of the repeated pages by merging. merged_page_values = merge_values.MergeLikeValuesFromSamePage( all_successful_page_values) # Now we have a bunch of values, but there is only one value_name per page. # Suppose page1 and page2 ran, producing values x and y. We want to print # x_by_url for page1 # x_by_url for page2 # x for page1, page2 combined # # y_by_url for page1 # y_by_url for page2 # y for page1, page2 combined # # We already have the x_by_url values in the values array. But, we will need # them indexable by the value name. # # The following dict maps value_name -> list of pages that have values of # that name. per_page_values_by_value_name = defaultdict(list) for value in merged_page_values: per_page_values_by_value_name[value.name].append(value) # We already have the x_by_url values in the values array. But, we also need # the values merged across the pages. And, we will need them indexed by # value name so that we can find them when printing out value names in # alphabetical order. merged_pages_value_by_value_name = {} if not self.had_errors_or_failures: for value in merge_values.MergeLikeValuesFromDifferentPages( all_successful_page_values): assert value.name not in merged_pages_value_by_value_name merged_pages_value_by_value_name[value.name] = value # sorted_value names will govern the order we start printing values. value_names = set([v.name for v in merged_page_values]) sorted_value_names = sorted(value_names) # Time to walk through the values by name, printing first the by_url values # and then the merged_site value. for value_name in sorted_value_names: per_page_values = per_page_values_by_value_name.get(value_name, []) # Sort the values by their url sorted_per_page_values = list(per_page_values) sorted_per_page_values.sort( key=lambda per_page_values: per_page_values.page.display_name) # Output the _by_url results. num_successful_pages_for_this_value_name = ( num_successful_pages_for_value_name[value_name]) for per_page_value in sorted_per_page_values: self._ComputePerPageValue( per_page_value, num_successful_pages_for_this_value_name) # Output the combined values. merged_pages_value = merged_pages_value_by_value_name.get( value_name, None) if merged_pages_value: self._computed_summary_values.append(merged_pages_value) self._interleaved_computed_per_page_values_and_summaries.append( merged_pages_value)
def _ComputePerPageValues(self, all_page_specific_values): all_successful_page_values = [ v for v in all_page_specific_values if not (isinstance(v, skip.SkipValue)) ] # We will later need to determine how many values were originally created # for each value name, to apply a workaround meant to clean up the printf # output. num_successful_pages_for_key = defaultdict(int) for v in all_successful_page_values: num_successful_pages_for_key[self._key_func(v)] += 1 # By here, due to page repeat options, all_values_from_successful_pages # contains values of the same name not only from mulitple pages, but also # from the same name. So even if, for instance, only one page ran, it may # have run twice, producing two 'x' values. # # So, get rid of the repeated pages by merging. merged_page_values = merge_values.MergeLikeValuesFromSamePage( all_successful_page_values, self._key_func) # Now we have a bunch of values, but there is only one value_name per page. # Suppose page1 and page2 ran, producing values x and y. We want to print # x for page1 # x for page2 # x for page1, page2 combined # # y for page1 # y for page2 # y for page1, page2 combined # # We already have the x values in the values array. But, we will need # them indexable by summary key. # # The following dict maps summary_key -> list of pages that have values of # that name. per_page_values_by_key = defaultdict(list) for value in merged_page_values: per_page_values_by_key[self._key_func(value)].append(value) # We already have the x values in the values array. But, we also need # the values merged across the pages. And, we will need them indexed by # summary key so that we can find them when printing out value names in # alphabetical order. merged_pages_value_by_key = {} if not self._had_failures: for value in merge_values.MergeLikeValuesFromDifferentPages( merged_page_values, self._key_func): value_key = self._key_func(value) assert value_key not in merged_pages_value_by_key merged_pages_value_by_key[value_key] = value keys = sorted(set([self._key_func(v) for v in merged_page_values])) # Time to walk through the values by key, printing first the page-specific # values and then the merged_site value. for key in keys: per_page_values = per_page_values_by_key.get(key, []) # Sort the values by their URL. sorted_per_page_values = list(per_page_values) sorted_per_page_values.sort( key=lambda per_page_values: per_page_values.page.name) # Output the page-specific results. num_successful_pages_for_this_key = ( num_successful_pages_for_key[key]) for per_page_value in sorted_per_page_values: self._ComputePerPageValue(per_page_value, num_successful_pages_for_this_key) # Output the combined values. merged_pages_value = merged_pages_value_by_key.get(key, None) if merged_pages_value: self._computed_summary_values.append(merged_pages_value) self._interleaved_computed_per_page_values_and_summaries.append( merged_pages_value)