def testFilter(self):
#
# construct a test data frame with no index and repeating group index column 'Var'
#
testdf = pd.DataFrame(
[
["A", 1.0, False, True, False, True],
["A", 2.0, False, True, False, True],
["A", 3.0, False, True, False, True],
["B", 1.0, True, True, False, False],
["B", 1.0, True, True, False, False],
["B", 2.0, True, True, False, False],
["C", 1.0, True, False, True, False],
["C", 1.0, True, False, True, False],
["C", 1.0, True, False, True, False],
],
columns = [Var, Val, one_equal, one_diff, all_equal, all_diff]
)
#
# test all combinations of anytestrun and operator if the filtered result matches
# the corresponding column
#
for combi in (one_diff, one_equal, all_diff, all_equal):
any, op = combi.split("_")
f = IPETFilter(operator = op, anytestrun = any, datakey = "Val")
f_result = f.applyListOperator(testdf, ["Var"])
self.assertTrue(np.all(f_result["Val"] == testdf[combi]),
"Wrong list operator result for combination {}:\n{}\n!=\n{}\n".format(combi, f_result, testdf[combi]))
def test_evalformat(self):
ex = Experiment()
ex.addOutputFile(test_out)
ex.collectData()
for (index, indexsplit) in ((index, indexsplit) for index in eval_index
for indexsplit in eval_indexsplit):
for (cols, fgs) in ((cols, fgs) for cols in self.test_cols
for fgs in self.test_fgs):
ev = IPETEvaluation(index=index, indexsplit=indexsplit)
if cols is not None:
for (ind_c, ind_a) in cols:
col = IPETEvaluationColumn(**columns[ind_c])
if col_filters[ind_c] is not None:
colfilter = IPETFilter(**col_filters[ind_c])
col.addFilter(colfilter)
if ind_a:
agg = Aggregation(**aggs[ind_c])
col.addAggregation(agg)
ev.addColumn(col)
if fgs is not None:
for ind in fgs:
fg = IPETFilterGroup(**filtergroups[ind])
if filters[ind] is not None:
fgfilter = IPETFilter(**filters[ind])
fg.addFilter(fgfilter)
ev.addFilterGroup(fg)
try:
tab_long, tab_agg = ev.evaluate(ex)
except AttributeError as e:
self.assertTrue((
cols is None or fgs is None
), "Either the number of columns or the number of filtergroups should be 0."
)
continue
self.assertEqual(type(tab_long), pd.DataFrame,
"Type of long table wrong.")
self.assertEqual(type(tab_agg), pd.DataFrame,
"Type of aggregated table wrong.")
# do not allow rowindex to be empty
if indexsplit == 0:
indexsplit = 1
rowindex_level = len(index.split()[:indexsplit])
columns_level = len(index.split()[indexsplit:])
self.assertEqual(tab_long.columns.nlevels, columns_level + 1,
"Level of columnindex of long table wrong.")
self.assertEqual(tab_agg.index.nlevels, columns_level + 1,
"Level of rowindex of agg table wrong.")
self.assertEqual(tab_long.index.nlevels, rowindex_level,
"Level of rowindex of long table wrong.")
def testListOperators(self):
attributes = IPETFilter.listoperators
commonattributes = dict(datakey="A", anytestrun="all")
for op1 in attributes:
for op2 in attributes:
f1 = IPETFilter(operator=op1, **commonattributes)
f2 = IPETFilter(operator=op2, **commonattributes)
eq = f1.equals(f2)
self.assertEqual(eq, op1 == op2, self.assertionMessage(f1, f2))
def testFilterComparison(self):
# test if different operators are correctly distinguished
operatorlist = ["le", "ge", "lt", "gt", "eq", "neq"]
for operator1 in operatorlist:
for operator2 in operatorlist:
f1 = IPETFilter("A", "B", operator1)
f2 = IPETFilter("A", "B", operator2)
eq = f1.equals(f2)
self.assertEqual(eq, operator1 == operator2,
self.assertionMessage(f1, f2))
def testAnyAll(self):
# test if filters that have all attributes equal except for the anytestrun attribute are distinguished
commonattributes = dict(expression1="A",
expression2="B",
operator="eq",
active=True,
datakey="C")
possiblevalues = ["one", "all"]
for any1 in possiblevalues:
for any2 in possiblevalues:
f1 = IPETFilter(anytestrun=any1, **commonattributes)
f2 = IPETFilter(anytestrun=any2, **commonattributes)
eq = f1.equals(f2)
self.assertEqual(eq, any1 == any2,
self.assertionMessage(f1, f2))
def setUp(self):
"""
create an evaluation around a helper experiment
"""
self.ex = HelpExperiment()
ev = IPETEvaluation(defaultgroup="C1",
index="A B C",
fillin=True,
indexsplit=3)
ev.addColumn(
IPETEvaluationColumn(origcolname="D", alternative="100",
maxval=15))
fg = IPETFilterGroup("Test")
fi = IPETFilter(operator="keep", datakey="A")
fi.addChild(IPETValue("A1"))
fg.addFilter(fi)
ev.addFilterGroup(fg)
self.ev = ev
self.fg = fg
def setUp(self):
self.ex = HelpExperiment()
ev = IPETEvaluation(defaultgroup="C1",
index="A C"
)
ev.addColumn(IPETEvaluationColumn(origcolname="D"))
fg = IPETFilterGroup("Test")
fi = IPETFilter(operator="keep", datakey="A")
fi.addChild(IPETValue("A1"))
fg.addFilter(fi)
fg2 = IPETFilterGroup("Test2")
fi2 = IPETFilter(operator="keep", datakey="A")
fi2.addChild(IPETValue("A2"))
fg2.addFilter(fi2)
ev.addFilterGroup(fg2)
ev.addFilterGroup(fg)
self.ev = ev
self.fg = fg
def setUp(self):
"""Set up the evaluation
The evaluation has only one column
for the 'Data' key, but applies
filtering on the 'FilterData' key
"""
self.ex = HelperExperiment()
ev = IPETEvaluation(index="Index", indexsplit="1")
ev.addColumn(IPETEvaluationColumn(origcolname="Data"))
fg = IPETFilterGroup("TestGroup")
fi = IPETFilter(expression1="FilterData",
expression2=-1.0,
operator="eq")
fg.addFilter(fi)
ev.addFilterGroup(fg)
self.ev = ev
def testValueLists(self):
valuelist1 = [[IPETValue("A"),
IPETValue("B"),
IPETValue("C")],
[IPETValue("A"),
IPETValue("B"),
IPETValue("C")], [
IPETValue("A"),
]]
valuelist2 = [[IPETValue("A"),
IPETValue("B"),
IPETValue("C")],
[IPETValue("A"),
IPETValue("B"),
IPETValue("C")],
[IPETValue("A"),
IPETValue("B"),
IPETValue("C")]]
operators1 = IPETFilter.valueoperators + IPETFilter.valueoperators[:1]
operator2 = "keep"
for op, v1list, v2list in zip(operators1, valuelist1, valuelist2):
f1 = IPETFilter(datakey="ABC", operator=op)
f2 = IPETFilter(datakey="ABC", operator=operator2)
for v1 in v1list:
f1.addChild(v1)
for v2 in v2list:
f2.addChild(v2)
eq = f1.equals(f2)
shouldbeequal = (op == operator2) and len(v1list) == len(v2list)
self.assertEqual(eq, shouldbeequal, self.assertionMessage(f1, f2))