def test4append_values_bytestring(self):
"""
This unittest checks the append_values method with raw_match_object being a bytestring.
This should trigger a ValueError and append the match_string.
"""
event_type_detector = EventTypeDetector(
self.aminer_config, [self.stream_printer_event_handler])
# initialize all values.
t = time.time()
log_atom = LogAtom(
b'This is a string',
ParserMatch(
MatchElement('path', 'This is a string', b'This is a string',
None)), t, self.__class__.__name__)
event_type_detector.receive_atom(log_atom)
event_type_detector.values = [[[]]]
event_type_detector.append_values(log_atom, 0)
self.assertEqual(event_type_detector.values, [[['This is a string']]])
log_atom = LogAtom(
b'24.05.',
ParserMatch(MatchElement('path', '24.05.', b'24.05.', None)), t,
self.__class__.__name__)
event_type_detector.values = [[[]]]
event_type_detector.append_values(log_atom, 0)
self.assertEqual(event_type_detector.values, [[['24.05.']]])
def test3append_values_float(self):
"""This unittest checks the append_values method with raw_match_object being a float value."""
event_type_detector = EventTypeDetector(
self.aminer_config, [self.stream_printer_event_handler])
# initialize all values.
t = time.time()
log_atom = LogAtom(
b'22.2', ParserMatch(MatchElement('path', '22.2', 22.2, None)), t,
self.__class__.__name__)
event_type_detector.receive_atom(log_atom)
event_type_detector.values = [[[]]]
event_type_detector.append_values(log_atom, 0)
self.assertEqual(event_type_detector.values, [[[22.2]]])
log_atom = LogAtom(b'22',
ParserMatch(MatchElement('path', '22', 22, None)),
t, self.__class__.__name__)
event_type_detector.values = [[[]]]
event_type_detector.append_values(log_atom, 0)
self.assertEqual(event_type_detector.values, [[[22]]])
log_atom = LogAtom(
b'22.2', ParserMatch(MatchElement('path', '22', b'22', None)), t,
self.__class__.__name__)
event_type_detector.values = [[[]]]
event_type_detector.append_values(log_atom, 0)
self.assertEqual(event_type_detector.values, [[[22]]])
def test5check_value_reduction(self):
"""This unittest checks the functionality of reducing the values when the maxNumVals threshold is reached."""
event_type_detector = EventTypeDetector(
self.aminer_config, [self.stream_printer_event_handler])
t = time.time()
val_list = [[[]]]
for i in range(1, event_type_detector.max_num_vals + 1, 1):
log_atom = LogAtom(
str(i).encode(),
ParserMatch(MatchElement('path', str(i), i, None)), t,
self.__class__.__name__)
val_list[0][0].append(float(i))
self.assertTrue(event_type_detector.receive_atom(log_atom))
self.assertEqual(event_type_detector.values, val_list)
i += 1
log_atom = LogAtom(
str(i).encode(), ParserMatch(MatchElement('path', str(i), i,
None)), t,
self.__class__.__name__)
val_list[0][0].append(float(i))
self.assertTrue(event_type_detector.receive_atom(log_atom))
self.assertEqual(
event_type_detector.values,
[[val_list[0][0][-event_type_detector.min_num_vals:]]])
def getMatchElement(self, path, matchContext):
"""Find the maximum number of bytes belonging to an exec
argument.
@return a match when at least two bytes were found including
the delimiters."""
data = matchContext.matchData
matchLen = 0
matchValue = b''
if data[0] == ord(b'"'):
matchLen = data.find(b'"', 1)
if matchLen == -1:
return None
matchValue = data[1:matchLen]
matchLen += 1
elif data.startswith(b'(null)'):
matchLen = 6
matchValue = None
else:
# Must be upper case hex encoded:
nextValue = -1
for dByte in data:
if (dByte >= 0x30) and (dByte <= 0x39):
dByte -= 0x30
elif (dByte >= 0x41) and (dByte <= 0x46):
dByte -= 0x37
else:
break
if nextValue == -1:
nextValue = (dByte<<4)
else:
matchValue += bytearray(((nextValue|dByte),))
nextValue = -1
matchLen += 1
if nextValue != -1:
return None
matchData = data[:matchLen]
matchContext.update(matchData)
return MatchElement(
"%s/%s" % (path, self.elementId), matchData, matchValue, None)
def test6persist_and_load_data(self):
"""This unittest checks the functionality of the persistence by persisting and reloading values."""
event_type_detector = EventTypeDetector(
self.aminer_config, [self.stream_printer_event_handler])
t = time.time()
log_atom = LogAtom(
b'22.2', ParserMatch(MatchElement('path', '22.2', 22.2, None)), t,
self.__class__.__name__)
event_type_detector.receive_atom(log_atom)
event_type_detector.do_persist()
event_type_detector_loaded = EventTypeDetector(
self.aminer_config, [self.stream_printer_event_handler])
self.assertEqual(event_type_detector.variable_key_list,
event_type_detector_loaded.variable_key_list)
self.assertEqual(event_type_detector.values,
event_type_detector_loaded.values)
self.assertEqual(event_type_detector.longest_path,
event_type_detector_loaded.longest_path)
self.assertEqual(event_type_detector.check_variables,
event_type_detector_loaded.check_variables)
self.assertEqual(event_type_detector.num_eventlines,
event_type_detector_loaded.num_eventlines)
def run_histogram_analysis(self, number_of_pathes, amplifier):
results = [None] * self.iterations
avg = 0
z = 0
while z < self.iterations:
modulo_time_bin_definition = ModuloTimeBinDefinition(
86400, 86400 / number_of_pathes, 0, 1, number_of_pathes, False)
histogram_data = HistogramData('match/crontab',
modulo_time_bin_definition)
histogram_analysis = HistogramAnalysis(
self.aminer_config,
[(histogram_data.property_path, modulo_time_bin_definition)],
amplifier * self.waiting_time,
[self.stream_printer_event_handler], False, 'Default')
i = 0
seconds = time.time()
t = seconds
while int(time.time() - seconds) < self.waiting_time:
p = process_time()
rand = random.randint(0, 100000)
seconds = seconds + process_time() - p
match_element = MatchElement('match/crontab', t + rand,
t + rand, [])
log_atom = LogAtom(histogram_data.bin_data,
ParserMatch(match_element), t + i,
histogram_analysis)
histogram_analysis.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 % (
histogram_analysis.__class__.__name__, avg, results,
'%d bin(s) and output after %d elements.' %
(number_of_pathes, amplifier * self.waiting_time))
def test6receive_atom(self):
"""
This unittest tests if atoms are sorted to the right distribution and if the update steps also work properly.
Therefore the assumption that after 200 values the VTD with the default parameters can change to the right distribution.
"""
# load data
with open('unit/data/vtd_data/uni_data_test6', 'rb') as f:
uni_data_list = pickle.load(f) # skipcq: BAN-B301
with open('unit/data/vtd_data/nor_data_test6', 'rb') as f:
nor_data_list = pickle.load(f) # skipcq: BAN-B301
with open('unit/data/vtd_data/beta1_data_test6', 'rb') as f:
beta1_data_list = pickle.load(f) # skipcq: BAN-B301
uni_data_list = uni_data_list * 10
nor_data_list = nor_data_list * 10
beta1_data_list = beta1_data_list * 10
vtd_arguments = [(100, 50), (110, 55), (90, 45), (80, 40), (70, 35)]
for init, update in vtd_arguments:
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=init,
num_update=update,
div_thres=0.8,
sim_thres=0.3,
num_pause_others=0)
t = time.time()
stat_data = b'True'
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
# initialize data
for i in range(init):
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['stat', [stat_data.decode()], True], result,
(init, update, result))
# static -> static
for i in range(update):
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['stat', [stat_data.decode()], True], result,
(init, update, result))
# static -> uni
for uni_data in uni_data_list[:init]:
log_atom = LogAtom(
uni_data,
ParserMatch(MatchElement('', uni_data, str(uni_data),
None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
pos_distr = vtd.alternative_distribution_types[0][0]
self.assertTrue(
result[0] == 'uni'
or 'uni' in [distr[0] for distr in pos_distr],
(init, update, result))
# uni -> others
for i in range(update):
stat_data = bytes(str((i % 75) * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['others', 0], result, (init, update, result))
# others -> d
for i in range(update):
stat_data = bytes(str((i % 10) * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual('d', result[0], (init, update, result))
# reset all
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=init,
num_update=update,
div_thres=0.3,
sim_thres=0.5,
num_pause_others=0,
num_d_bt=30)
# initialize with d
for i in range(init):
stat_data = bytes(str((i % 10) * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual('d', result[0], (init, update, result))
# discrete to others with new values
for uni_data in uni_data_list[:init]:
log_atom = LogAtom(
uni_data,
ParserMatch(MatchElement('', uni_data, str(uni_data),
None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['others', 0], result, (init, update, result))
# reset all
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=init,
num_update=update,
div_thres=0.3,
sim_thres=0.5,
num_pause_others=0,
num_d_bt=20)
# initialize with d
for i in range(init):
stat_data = bytes(str((i % 10) * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual('d', result[0], (init, update, result))
# discrete to others without new values, low num_d_bt
for i in range(update):
stat_data = bytes(str((i % 3) * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['others', 0], result, (init, update, result))
# reset all
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=init,
num_update=update,
div_thres=0.3,
sim_thres=0.5,
num_pause_others=0,
num_d_bt=100)
# initialize with d
for i in range(init):
stat_data = bytes(str((i % 10) * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual('d', result[0], (init, update, result))
# discrete to others without new values, high num_d_bt
for i in range(update):
stat_data = bytes(str((i % 3) * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertNotEqual(['others', 0], result, (init, update, result))
# reset all
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=init,
num_update=update,
div_thres=0.3,
sim_thres=0.3,
num_pause_others=0)
t = time.time()
stat_data = b'True'
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
# initialize data
for i in range(init):
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['stat', [stat_data.decode()], True], result,
(init, update, result))
# static -> asc
for i in range(init):
stat_data = bytes(str(i * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['asc', 'float'], result, (init, update, result))
# asc -> desc
for i in range(init, 0, -1):
stat_data = bytes(str(i * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['desc', 'float'], result, (init, update, result))
# reset all
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=init,
num_update=update,
div_thres=0.3,
sim_thres=0.3,
num_pause_others=0)
t = time.time()
stat_data = b'True'
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
# initialize data
for i in range(init):
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['stat', [stat_data.decode()], True], result,
(init, update, result))
# static -> nor
for nor_data in nor_data_list[:init]:
log_atom = LogAtom(
nor_data,
ParserMatch(MatchElement('', nor_data, str(nor_data),
None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
pos_distr = vtd.alternative_distribution_types[0][0]
self.assertTrue(
result[0] == 'nor'
or 'nor' in [distr[0] for distr in pos_distr],
(init, update, result))
# nor -> beta1
for beta1_data in beta1_data_list[:init]:
log_atom = LogAtom(
beta1_data,
ParserMatch(
MatchElement('', beta1_data, str(beta1_data), None)),
t, self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
pos_distr = vtd.alternative_distribution_types[0][0]
self.assertTrue(
(result[0] == 'beta' and result[-1] == 1) or 'beta1'
in [distr[0] + str(distr[-1])
for distr in pos_distr], (init, update, result))
# reset all
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=init,
num_update=update,
div_thres=0.3,
sim_thres=0.3,
num_pause_others=0)
t = time.time()
stat_data = b'True'
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
# initialize data
for i in range(init):
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual(['stat', [stat_data.decode()], True], result,
(init, update, result))
# static -> unq
vtd.test_ks_int = False
unq_data_list = [bytes(str(i), 'utf-8') for i in range(init)]
random.shuffle(unq_data_list)
for unq_data in unq_data_list:
log_atom = LogAtom(
unq_data,
ParserMatch(MatchElement('', unq_data, unq_data, None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
vtd.receive_atom(log_atom)
result = vtd.var_type[0][0]
self.assertEqual('unq', result[0], (init, update, result))
def test4detect_var_type(self):
"""This unittest tests possible scenarios of the detect_var_type method."""
num_init = 100
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init)
t = time.time()
# test the 'static' path of detect_var_type
stat_data = b'5.3.0-55-generic'
log_atom = LogAtom(
stat_data,
ParserMatch(MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
# check what happens if less than numMinAppearance values are available
for i in range(num_init):
self.assertTrue(etd.receive_atom(log_atom))
result = vtd.detect_var_type(0, 0)
self.assertEqual(['stat', [stat_data.decode()], False], result)
# reset etd and vtd for clear results.
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init)
# test ascending with float values
for i in range(num_init):
stat_data = bytes(str(i * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
result = vtd.detect_var_type(0, 0)
self.assertEqual(['asc', 'float'], result)
# reset etd and vtd for clear results.
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init)
# test ascending with integer values
for i in range(num_init):
stat_data = bytes(str(i), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
result = vtd.detect_var_type(0, 0)
self.assertEqual(['asc', 'int'], result)
# reset etd and vtd for clear results.
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init)
# test descending with float values
for i in range(num_init, 0, -1):
stat_data = bytes(str(i * 0.1), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
result = vtd.detect_var_type(0, 0)
self.assertEqual(['desc', 'float'], result)
# reset etd and vtd for clear results.
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init)
# test descending with integer values
for i in range(num_init, 0, -1):
stat_data = bytes(str(i), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
result = vtd.detect_var_type(0, 0)
self.assertEqual(['desc', 'int'], result)
# reset etd and vtd for clear results.
etd = EventTypeDetector(self.aminer_config,
[self.stream_printer_event_handler])
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init,
div_thres=0.3,
test_ks_int=True)
# test 'num_init' and 'div_thres'
# prevent results from becoming asc or desc
stat_data = bytes(str(99), 'utf-8')
log_atom = LogAtom(
stat_data,
ParserMatch(MatchElement('', stat_data.decode(), stat_data, None)),
t, self.__class__.__name__)
etd.receive_atom(log_atom)
values = [float(stat_data)]
for i in range(99):
stat_data = bytes(str(i), 'utf-8')
values.append(float(stat_data))
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
result = vtd.detect_var_type(0, 0)
# this means that the uniformal distribution must be detected.
self.assertNotEqual(
result[0] == 'uni' or 'uni' in [distr[0] for distr in result[-1]],
result)
# test 'divThres' option for the continuous distribution
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init,
div_thres=1.0,
test_ks_int=True)
result = vtd.detect_var_type(0, 0)
self.assertEqual(['unq', values], result)
# test 'testInt' option for the continuous distribution
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init,
div_thres=0.3,
test_ks_int=False)
result = vtd.detect_var_type(0, 0)
self.assertEqual(['unq', values], result)
# test 'simThres' option to result in 'others'
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init,
div_thres=0.5,
test_ks_int=False,
sim_thres=0.5)
values = []
for i in range(100):
stat_data = bytes(str((i % 50) * 0.1), 'utf-8')
values.append(float(stat_data))
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
result = vtd.detect_var_type(0, 0)
# at least (1 - 'simThresh') * 'numMinAppearance' and maximal 'numMinAppearance' * 'divThres' - 1 unique values must exist.
self.assertEqual(['others', 0], result)
# test discrete result
vtd = VariableTypeDetector(self.aminer_config,
[self.stream_printer_event_handler],
etd,
num_init=num_init,
div_thres=0.5,
test_ks_int=False,
sim_thres=0.3)
values = []
for i in range(num_init):
stat_data = bytes(str((i % 50) * 0.1), 'utf-8')
values.append(float(stat_data))
log_atom = LogAtom(
stat_data,
ParserMatch(
MatchElement('', stat_data.decode(), stat_data, None)), t,
self.__class__.__name__)
self.assertTrue(etd.receive_atom(log_atom))
result = vtd.detect_var_type(0, 0)
values_set = list(set(values))
values_app = [0 for _ in range(len(values_set))]
for value in values:
values_app[values_set.index(value)] += 1
values_app = [x / len(values) for x in values_app]
self.assertEqual(['d', values_set, values_app, len(values)], result)
def run_match_value_average_change_detector(self, number_of_pathes):
results = [None] * self.iterations
avg = 0
z = 0
while z < self.iterations:
i = 0
path_list = []
while i < number_of_pathes:
path_list.append(self.integerd + str(i % number_of_pathes))
i = i + 1
seconds = time.time()
t = time.time()
match_value_average_change_detector = MatchValueAverageChangeDetector(
self.aminer_config, [self.stream_printer_event_handler], None,
path_list, 2, t, True, False, 'Default')
i = 0
while i < number_of_pathes:
match_element = MatchElement(self.integerd + str(i),
'%s' % str(t), t, [])
log_atom = LogAtom(match_element.get_match_object(),
ParserMatch(match_element), t,
match_value_average_change_detector)
match_value_average_change_detector.receive_atom(log_atom)
match_element = MatchElement(self.integerd + str(i),
'%s' % str(t + 0.1), t + 0.1, [])
log_atom = LogAtom(match_element.get_match_object(),
ParserMatch(match_element), t + 0.1,
match_value_average_change_detector)
match_value_average_change_detector.receive_atom(log_atom)
match_element = MatchElement(self.integerd + str(i),
'%s' % str(t + 0.2), t + 0.2, [])
log_atom = LogAtom(match_element.get_match_object(),
ParserMatch(match_element), t + 0.2,
match_value_average_change_detector)
match_value_average_change_detector.receive_atom(log_atom)
match_element = MatchElement(self.integerd + str(i),
'%s' % str(t + 10), t + 10, [])
log_atom = LogAtom(match_element.get_match_object(),
ParserMatch(match_element), t + 10,
match_value_average_change_detector)
match_value_average_change_detector.receive_atom(log_atom)
i = i + 1
i = 0
t = time.time()
while int(time.time() - seconds) < self.waiting_time:
p = process_time()
r = random.randint(0, 1) / 100 * 0.05
seconds = seconds + p - process_time()
delta = 0.15 + r
match_element = MatchElement(
self.integerd + str(i % number_of_pathes),
'%s' % str(t + delta), t + delta, [])
log_atom = LogAtom(match_element.get_match_object(),
ParserMatch(match_element), t + delta,
match_value_average_change_detector)
match_value_average_change_detector.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 % (
match_value_average_change_detector.__class__.__name__, avg,
results, self.different_pathes % number_of_pathes)