def test_TPSpan():
TP = set()
Ep = [b_f, c_s_1, c_f_1]
Ep2 = [b_f, c_s_1, c_f_1]
Ep3 = [b_f, c_s_1, c_f_1]
cs = Projected_cs([b_s])
cs.Ep_list = Ep
cs2 = Projected_cs([b_s])
cs2.Ep_list = Ep2
cs3 = Projected_cs([b_s])
cs3.Ep_list = Ep3
db = DB([b_s])
db.ES = [cs, cs2, cs3]
TPSpan([b_s], db, 1, TP)
for pattern in TP:
print(pattern)
expected_result = {(b_s, b_f, f_s, f_f), (b_s, b_f, c_s, c_f), (b_s, b_f),
(b_s, b_f, c_s, f_s, f_f, c_f)}
t.test(TP == expected_result, 'TPSpan Test #1')
def Test_PandaTime():
patternD = CreatePattern(None, D)
patternDE = CreatePattern(patternD, E)
testDE = np.array([[None, D, E], [D, '=', 's'], [E, '*', '=']])
t.test(np.array_equal(patternDE, testDE),
'Pattern comparison with panda time')
def Test_SkipEmptyDays():
pre = GenericPreprocessor(CSV_PATH, ',', COLUMNS, getState, logger)
mdb, skippedDays = pre.GenerateTemporalMdb()
output = len(skippedDays)
m = 'Skipped empty days: [{} | {}]'.format(output, EXPECTED_SKIPPED)
t.test(output == EXPECTED_SKIPPED, m)
def Test_ExtractStateNames_ReturnExpectedLength():
p = Patterns.A
states = MineIndexSet.ExtractStateNames(p)
expected_states = [FStates.D]
m = 'Return expected length'
t.test(len(states) == len(expected_states), m)
def Test_ReturnCorrectNumberOfClients():
pre = GenericPreprocessor(CSV_PATH, ',', COLUMNS, getState, logger)
mdb, skippedDays = pre.GenerateTemporalMdb()
output = len(mdb)
m = 'Return correct number of clients: Got[{}] expected[{}]'.format(
output, EXPECTED_CS_LENGTH)
t.test(output == EXPECTED_CS_LENGTH, m)
def Test_GenerateThreePatterns():
patternA = CreatePattern(None, A)
patternAB = CreatePattern(patternA, B)
patternABC = CreatePattern(patternAB, C)
testABC = np.array([[None, A, B, C], [A, '=', 'c', 'f'],
[B, '*', '=', 'o'], [C, '*', '*', '=']])
t.test(np.array_equal(patternABC, testABC), 'Generate 3-patterns')
def test_db_construct():
#two-pattern a_p, no pointsets, 3 equal client sequences
Ep_list = [c_s, a_f, c_f, d_s, d_f]
Ep_list2 = [c_s, a_f, c_f, d_s, d_f]
Ep_list3 = [c_s, a_f, c_f, d_s, d_f]
prfx = [a_s]
cs = Projected_cs(prfx)
cs.Ep_list = Ep_list
cs2 = Projected_cs(prfx)
cs2.Ep_list = Ep_list2
cs3 = Projected_cs(prfx)
cs3.Ep_list = Ep_list3
cs_list = [cs, cs2, cs3]
db = DB(prfx)
db.ES = cs_list
temp = db_construct(db, db.Pattern + [a_f]).ES
result = []
for proj_cs in temp:
result.append(proj_cs.Ep_list)
expected_result = [[d_s], [d_s], [d_s]]
t.test(result == expected_result, 'Construct_db Test #1')
#two-pattern a_p, a_p is pointset, result should be empty
Ep_list = [c_s_1, a_f_1, c_f, d_s, d_f]
Ep_list2 = [c_s_2, a_f_2, c_f, d_s, d_f]
Ep_list3 = [c_s, a_f, c_f, d_s, d_f]
prfx = [a_s_1]
prfx2 = [a_s_2]
prfx3 = [a_s_2]
cs = Projected_cs(prfx)
cs.Ep_list = Ep_list
cs2 = Projected_cs(prfx2)
cs2.Ep_list = Ep_list2
cs3 = Projected_cs(prfx3)
cs3.Ep_list = Ep_list3
db.ES = [cs, cs2, cs3]
db.Pattern = [a_s_1]
temp = db_construct(db, db.Pattern + [a_f_1]).ES
result = []
for proj_cs in temp:
result.append(proj_cs.Ep_list)
print(proj_cs.Ep_list)
def Test_ExtractStateNames_ReturnExpectetStates():
p = Patterns.C
states = MineIndexSet.ExtractStateNames(p)
expected_states = ['F', 'G', 'H']
result = True
for i in range(0, 3):
if states[i] != expected_states[i]:
result = False
break
m = 'Return list of state names'
t.test(result, m)
def Test_GenerateOnePatterns():
patternA = CreatePattern(None, A)
patternB = CreatePattern(None, B)
patternC = CreatePattern(None, C)
testA = np.array([[None, A], [A, '=']])
testB = np.array([[None, B], [B, '=']])
testC = np.array([[None, C], [C, '=']])
result = (np.array_equal(patternA, testA)
and np.array_equal(patternB, testB)
and np.array_equal(patternC, testC))
t.test(result, 'Generate 1-patterns')
def test_point_pruning():
#test with prefix of length 1
FE = {a_f, b_f, c_s, c_f, d_s, d_f}
expected_return = {a_f, c_s, d_s}
prfx = [a_s, a_f, a_s]
t.test(point_pruning(FE, prfx) == expected_return, 'PointPruning Test #1')
#Test on prefix with length 1
FE = {a_s, a_f, b_f, c_s, c_f, d_s, d_f}
expected_return = {a_s, a_f, c_s, c_f, d_s}
prfx = [a_s, c_s]
t.test(point_pruning(FE, prfx) == expected_return, 'PointPruning Test #2')
def testSensorGetState():
start = pa.to_datetime('07:55')
end = pa.to_datetime('12:00')
sen = fic.Sensor('Test', range(1, 5), [fic.Period(start, end)])
# A wednesday
time = pa.to_datetime('11-11-2020 10:00')
m = 'Check Sensor getState in activeDay(middle): Return \'ON\''
t.test(sen.getState(time) == 'ON', m)
# A saturday
time = pa.to_datetime('14-11-2020 10:00')
m = 'Check Sensor getState outside activeDay(after falling edge): Return \'OFF\''
t.test(sen.getState(time) == 'OFF', m)
# A sunday
time = pa.to_datetime('15-11-2020 10:00')
m = 'Check Sensor getState outside activeDay(before raising edge): Return \'OFF\''
t.test(sen.getState(time) == 'OFF', m)
# A monday
time = pa.to_datetime('17-11-2020 10:00')
m = 'Check Sensor getState in activeDay(after raising edge): Return \'ON\''
t.test(sen.getState(time) == 'ON', m)
print()
def Test_GenerateTwoPatterns():
patternA = CreatePattern(None, A)
patternB = CreatePattern(None, B)
patternAB = CreatePattern(patternA, B)
patternAC = CreatePattern(patternA, C)
patternBC = CreatePattern(patternB, C)
testAB = np.array([[None, A, B], [A, '=', 'c'], [B, '*', '=']])
testAC = np.array([[None, A, C], [A, '=', 'f'], [C, '*', '=']])
testBC = np.array([[None, B, C], [B, '=', 'o'], [C, '*', '=']])
result = (np.array_equal(patternAB, testAB)
and np.array_equal(patternAC, testAC)
and np.array_equal(patternBC, testBC))
t.test(result, 'Generate 2-patterns')
def Test_useGenericPreprocessor_ThrowExceptionIfUsedPropertyIsNone_NoneProperty():
job = Job()
m = ''
isCatched = False
try:
job.useGenericPreprocessor()
except ArgumentNotSetError as e:
isCatched = True
m += e.argument
except:
pass
m = ('\'useGenericPreprocessor\' catched none properties: '
+ 'The following is not set[{}]'.format(m))
t.test(isCatched, m)
def Test_singleDayClientSequence_returns_correct_amount_of_data():
pre = GenericPreprocessor(CSV_PATH, ',', COLUMNS, getState, logger)
mdb, skippedDays = pre.GenerateTemporalMdb()
data = mdb[0]
expected = {
'ClientID': 0,
'State': 'Test1_1',
'Start': pa.to_datetime('2013-07-01 00:07:00'),
'End': pa.to_datetime('2013-07-01 00:30:00')
}
# Compare output with expected
result = True
for col in data.columns:
if (data.at[0, col] != expected[col]):
result = False
break
t.test(result, 'Default singleDayClientSequence return correct data')
def testPeriods():
start = pa.to_datetime('07:55')
end = pa.to_datetime('12:00')
startS = pa.to_datetime('14:00')
endS = pa.to_datetime('15:00')
sen = fic.Sensor('Test', range(1, 5),
[fic.Period(start, end),
fic.Period(startS, endS)])
time = pa.to_datetime('01-01-2020 10:00')
# Inside
m = 'Check if time inside period: Return TRUE'
t.test(sen.inPeriods(time), m)
# Outside below
time = pa.to_datetime('01-01-2020 07:54')
m = 'Check if time outside below period: Return FALSE'
t.test(not sen.inPeriods(time), m)
# Outside above
time = pa.to_datetime('01-01-2020 12:01')
m = 'Check if time outside above period: Return FALSE'
t.test(not sen.inPeriods(time), m)
print()
def Test_useGenericPreprocessor_ThrowExceptionIfUsedPropertyIsNone_CorrectProperty():
m = '\'useGenericPreprocessor\' correct properties no error'
t.test(False, m)
def Test_run_ReturnsResultsOfRun():
m = '\'run\' returns result'
t.test(False, m)
def Test_run_SavesResultsInResult():
m = '\'run\' populate result'
t.test(False, m)
def one_patternTest():
time = MineIndexSet.GetFirstEndTime(Patterns.D)
e_time = str(FStates.F.End)[11:]
m = 'Test 1-pattern. Return first state end time'
t.test(time == e_time, m)
import testSuite as t
from algorithms.armada.CreateIndexSet import CreateIndexSet
from algorithms.armada import Storage
from preprocessors.Vent import VentPreprocessor
def Test_CreateInitialIndexSet():
pass
print('********************')
print('Testing CreateIndexSet.py')
print()
t.test(False, 'No tests made')
# PATH = 'datasets/vent-minute-shorter.csv'
# preprocessor = VentPreprocessor(PATH, ';')
# mdb = preprocessor.GenerateTemporalMdb(interval=5)
def Test_run_RemovesPreviousResults():
m = '\'run\' removes previous run results'
t.test(False, m)
def three_patternTest():
time = MineIndexSet.GetFirstEndTime(Patterns.C)
e_time = str(FStates.G.End)[11:]
m = 'Test 3-pattern. Return second state'
t.test(time == e_time, m)
