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)