def setUp(self):
self.session = patch_subset_method.create_without_codepoint_remapping(
).start_session(None, font_loader.FontLoader("./patch_subset/testdata/"))
self.session_with_remapping = patch_subset_method.create_with_codepoint_remapping(
).start_session(None, font_loader.FontLoader("./patch_subset/testdata/"))
self.session_with_prediction = patch_subset_method.create_with_codepoint_prediction(
50,
0.0).start_session(None, font_loader.FontLoader("./patch_subset/testdata/"))
def test_cached_file_load(self):
session = whole_font_pfe_method.start_session(
None, font_loader.FontLoader("./patch_subset/testdata/"))
session.page_view({"Roboto-Regular.ttf": u([0x61, 0x62])})
session = whole_font_pfe_method.start_session(
None, font_loader.FontLoader("./patch_subset/testdata/"))
session.page_view({"Roboto-Regular.ttf": u([0x63, 0x64])})
graphs = session.get_request_graphs()
self.assertEqual(len(graphs), 1)
self.assertTrue(
request_graph.graph_has_independent_requests(graphs[0], [
(35, 35 + ROBOTO_REGULAR_WOFF2_SIZE),
]))
def test_read_font(self):
with tempfile.TemporaryDirectory() as the_dir:
font_id = 'test.ttf'
font_contents = 'font-bytes-go-here'
with open(the_dir + '/' + font_id, 'w') as tmp_file:
tmp_file.write(font_contents)
the_bytes = font_loader.FontLoader(the_dir).load_font(font_id)
self.assertEqual(str(the_bytes, encoding='UTF-8'), font_contents)
def setUp(self):
flags.FLAGS(["auto-settings", "False"])
self.latin_method = combined_patch_subset_method.CombinedPatchSubsetMethod(
"latin")
self.arabic_indic_method = combined_patch_subset_method.CombinedPatchSubsetMethod(
"arabic_indic")
self.cjk_method = combined_patch_subset_method.CombinedPatchSubsetMethod(
"cjk")
self.unknown_method = combined_patch_subset_method.CombinedPatchSubsetMethod(
"invalid")
self.font_loader = font_loader.FontLoader("./patch_subset/testdata/")
def test_simulate_logged(self):
a_font_loader = font_loader.FontLoader("fonts/are/here")
self.assertEqual(
simulation.simulate_sequence(
self.page_view_sequence, self.mock_logged_pfe_method,
simulation.NetworkModel("slow", 0, 10, 10), a_font_loader),
[self.graph_1])
self.mock_logged_pfe_method.start_session.assert_called_once_with(
simulation.NetworkModel("slow", 0, 10, 10), a_font_loader)
self.mock_logged_pfe_session.page_view_proto.assert_has_calls(
[mock.call(page_view) for page_view in self.page_view_sequence])
self.mock_logged_pfe_session.get_request_graphs.assert_called_once_with(
)
def simulate_all(sequences,
pfe_methods,
network_models,
font_directory,
default_font_id=None):
"""Simulate the matrix of {sequences} x {pfe_methods} x {network_models}.
For each element compute a set of summary metrics, total time, total
request bytes sent, and total response bytes sent.
"""
a_font_loader = font_loader.FontLoader(font_directory, default_font_id)
failed_indices = []
results_by_method = collections.defaultdict(
lambda: collections.defaultdict(list))
idx = 0
for sequence in sequences:
sequence_results = collections.defaultdict(
lambda: collections.defaultdict(list))
try:
for method in pfe_methods:
if not is_network_sensitive(method):
graphs = simulate_sequence(sequence.page_views, method,
None, a_font_loader)
network_results = sequence_results[method.name()]
for network_model in network_models:
if is_network_sensitive(method):
graphs = simulate_sequence(sequence.page_views, method,
network_model,
a_font_loader)
network_results[network_model.name].append(
SequenceTotals(
totals_for_network(graphs, network_model),
sequence.id))
merge_results_by_method(sequence_results, results_by_method)
except Exception: # pylint: disable=broad-except
LOG.exception(
"Failure during sequence simulation. Dropping sequence from results."
)
failed_indices.append(idx)
idx += 1
return SimulationResults(dict(results_by_method), failed_indices)
def test_subsequent_subset_smaller(self):
session = optimal_pfe_method.start_session(
None, font_loader.FontLoader("./patch_subset/testdata/"),
InverseMockSubsetSizer())
session.page_view({"Roboto-Regular.ttf": u([1, 2, 3])})
session.page_view({"Roboto-Regular.ttf": u([4, 5])})
graphs = session.get_request_graphs()
self.assertEqual(len(graphs), 2)
self.assertTrue(
request_graph.graph_has_independent_requests(graphs[0], [
(0, 1000),
]))
self.assertTrue(request_graph.graph_has_independent_requests(graphs[1], []))
def test_simulate(self):
a_font_loader = font_loader.FontLoader("fonts/are/here")
self.assertEqual(
simulation.simulate_sequence(
self.page_view_sequence, self.mock_pfe_method,
simulation.NetworkModel("slow", 0, 10, 10), a_font_loader),
[self.graph_1])
self.mock_pfe_method.start_session.assert_called_once_with(
simulation.NetworkModel("slow", 0, 10, 10), a_font_loader)
usage = namedtuple("Usage", ["codepoints", "glyph_ids"])
self.mock_pfe_session.page_view.assert_has_calls([
mock.call({
"roboto": usage({1, 2, 3}, set()),
"open_sans": usage({4, 5, 6}, set()),
}),
mock.call({
"roboto": usage({7, 8, 9}, set()),
}),
mock.call({"open_sans": usage({10, 11, 12}, set())})
])
self.mock_pfe_session.get_request_graphs.assert_called_once_with()
def simulate_all(sequences,
pfe_methods,
network_models,
font_directory,
default_font_id=None):
"""Simulate the matrix of {sequences} x {pfe_methods} x {network_models}.
For each element compute a set of summary metrics, total time, total
request bytes sent, and total response bytes sent.
"""
a_font_loader = font_loader.FontLoader(font_directory, default_font_id)
result = dict()
for method in pfe_methods:
model_totals = dict()
if hasattr(method, "network_sensitive") and callable(
method.network_sensitive) and method.network_sensitive():
for network_model in network_models:
totals = []
for sequence in sequences:
graphs = simulate_sequence(sequence, method, network_model,
a_font_loader)
totals.extend(totals_for_network(graphs, network_model))
model_totals[network_model.name] = totals
else:
graph_collection = []
for sequence in sequences:
graphs = simulate_sequence(sequence, method, None,
a_font_loader)
graph_collection.append(graphs)
for network_model in network_models:
totals = []
for graphs in graph_collection:
totals.extend(totals_for_network(graphs, network_model))
model_totals[network_model.name] = totals
result[method.name()] = model_totals
return result
def setUp(self):
self.session = range_request_pfe_method.start_session(
None, font_loader.FontLoader("./patch_subset/testdata/"), 10)
def setUp(self):
self.session = whole_font_pfe_method.start_session(
None, font_loader.FontLoader("./patch_subset/testdata/"))
def setUp(self):
self.session = optimal_one_font_method.start_session(None,
font_loader.FontLoader("./patch_subset/testdata/"), MockSubsetSizer())
def setUp(self):
self.session = unicode_range_pfe_method.start_session(
None, font_loader.FontLoader("./patch_subset/testdata/"),
MockSubsetSizer())
