def run_atom_filters_match_value_filter(self, number_of_pathes):
results = [None] * self.iterations
avg = 0
z = 0
while z < self.iterations:
new_match_path_detector = NewMatchPathDetector(
self.aminer_config, [self.stream_printer_event_handler],
'Default', True)
subhandler_filter = SubhandlerFilter([],
stop_when_handled_flag=True)
i = 0
dictionary = {}
while i < 1000000:
dictionary[i] = new_match_path_detector
i = i + 1
i = 0
while i < number_of_pathes:
match_value_filter = MatchValueFilter(
self.integerd + str(i % number_of_pathes), dictionary,
None)
subhandler_filter.add_handler(match_value_filter,
stop_when_handled_flag=True)
i = i + 1
t = round(time.time(), 3)
seconds = time.time()
i = 0
while int(time.time() - seconds) < self.waiting_time:
decimal_integer_value_me = DecimalIntegerValueModelElement(
'd' + str(i % number_of_pathes),
DecimalIntegerValueModelElement.SIGN_TYPE_NONE,
DecimalIntegerValueModelElement.PAD_TYPE_NONE)
match_context = MatchContext(str(i).encode())
match_element = decimal_integer_value_me.get_match_element(
'integer', match_context)
log_atom = LogAtom(match_element.match_string,
ParserMatch(match_element), t,
match_value_filter)
subhandler_filter.receive_atom(log_atom)
i = i + 1
results[z] = i
z = z + 1
avg = avg + i
avg = avg / self.iterations
type(self).result = self.result + self.result_string % (
subhandler_filter.__class__.__name__, avg, results,
'%d different %ss with a dictionary of %ss.' %
(number_of_pathes, match_value_filter.__class__.__name__,
new_match_path_detector.__class__.__name__))
def test2atom_filter_match_action(self):
"""This test case proves the functionality of the AtomFilters"""
description = "Test2Rules"
newMatchPathDetector = NewMatchPathDetector(self.aminer_config, [self.stream_printer_event_handler], 'Default', False)
logAtomFixedDME = LogAtom(self.fixed_dme.fixed_data, ParserMatch(self.match_element_fixed_dme), time(), newMatchPathDetector)
subhandlerFilter = SubhandlerFilter([newMatchPathDetector])
self.analysis_context.register_component(subhandlerFilter, description)
self.analysis_context.register_component(newMatchPathDetector, description + "2")
self.assertTrue(subhandlerFilter.receive_atom(logAtomFixedDME))
def test2receive_atom_unhandled(self):
"""In this test case no handler can handle the log atom."""
description = "Test2AtomFilters"
new_match_path_detector = NewMatchPathDetector(
self.aminer_config, [self.stream_printer_event_handler], 'Default',
False)
self.analysis_context.register_component(new_match_path_detector,
description)
t = time.time()
log_atom_fixed_dme = LogAtom(self.fixed_dme.fixed_data,
ParserMatch(self.match_element_fixed_dme),
t, new_match_path_detector)
subhandler_filter = SubhandlerFilter([], True)
self.assertTrue(not subhandler_filter.receive_atom(log_atom_fixed_dme))
def test3receive_atom_handled_by_more_handlers(self):
"""In this test case more than one handler can handle the log atom. The impact of the stop_when_handled flag is tested."""
description = "Test3AtomFilters"
other_description = "Test3OtherAtomFilters"
new_match_path_detector = NewMatchPathDetector(
self.aminer_config, [self.stream_printer_event_handler], 'Default',
False)
self.analysis_context.register_component(new_match_path_detector,
description)
t = time.time()
other_new_match_path_detector = NewMatchPathDetector(
self.aminer_config, [self.stream_printer_event_handler], 'Default',
False)
self.analysis_context.register_component(other_new_match_path_detector,
other_description)
log_atom_fixed_dme = LogAtom(self.fixed_dme.fixed_data,
ParserMatch(self.match_element_fixed_dme),
t, new_match_path_detector)
subhandler_filter = SubhandlerFilter(
[new_match_path_detector, other_new_match_path_detector], False)
self.assertTrue(subhandler_filter.receive_atom(log_atom_fixed_dme))
result = self.output_stream.getvalue()
self.reset_output_stream()
new_match_path_detector.receive_atom(log_atom_fixed_dme)
resultFixedDME = self.output_stream.getvalue()
self.reset_output_stream()
other_new_match_path_detector.receive_atom(log_atom_fixed_dme)
result_decimal_integer_value_me = self.output_stream.getvalue()
self.assertEqual(result,
resultFixedDME + result_decimal_integer_value_me)