def test_init(self):
assertionA = Assertion("assertion A")
assertionB = Assertion("assertion B")
assertionC = Assertion("assertion C")
assertionX = Assertion("assertion X")
criterionA = Criterion(assertionA, True)
criterionC = Criterion(assertionC, True)
criterionNB = Criterion(assertionB, False)
criterionX = Criterion(assertionX, True)
diagnosis = Diagnosis(
'Diagnosis name',
{criterionA, criterionNB, criterionC, criterionX}, 0.25)
self.assertEqual(diagnosis.name, "Diagnosis_name")
self.assertEqual(diagnosis.criteria,
{criterionA, criterionNB, criterionC, criterionX})
self.assertEqual(diagnosis.assertions,
{assertionA, assertionB, assertionC, assertionX})
self.assertEqual(diagnosis.prevalence, 0.25)
def test_init(self):
assertionA = Assertion("assertion A")
criterionA = Criterion(assertionA, True)
parent_node = Node(assertionA)
child_node = Node(criterionA, parent_node)
self.assertEqual(parent_node.object, assertionA)
self.assertEqual(parent_node.parent, None)
self.assertEqual(child_node.parent, parent_node)
self.assertEqual(child_node.children, ())
self.assertEqual(parent_node.children, (child_node,))
self.assertEqual(parent_node.root, True)
self.assertEqual(child_node.root, False)
self.assertEqual(parent_node.leaf, False)
self.assertEqual(child_node.leaf, True)
def test_validate(self):
assertionA = Assertion("assertion A", "is assertion A true?")
assertionB = Assertion("assertion B", "is assertion B true?")
assertionC = Assertion("assertion C", "is assertion C true?")
assertionX = Assertion("assertion X", "is assertion X true?")
diagnosis1 = Diagnosis(
'Diagnosis 1', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.25)
diagnosis2 = Diagnosis(
'Diagnosis 2', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.5)
with self.assertRaises(Exception):
Issue("Issue name", {diagnosis1, diagnosis2})
def test_undiagnosable(self):
assertionA = Assertion("assertion A")
assertionB = Assertion("assertion B")
assertionC = Assertion("assertion C")
assertionX = Assertion("assertion X")
diagnosis1 = Diagnosis(
'Diagnosis 1', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.25)
diagnosis2 = Diagnosis(
'Diagnosis 2', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True)
}, 0.5)
self.assertEqual(undiagnosable({diagnosis1, diagnosis2}),
{diagnosis1, diagnosis2})
from osler.issue import Issue
from osler.engine import Matrix
#Defining assertions
HBsAg_pos = Assertion("HBsAg = positive")
aHDV_neg = Assertion("anti-HDV = negative")
aHBc_pos = Assertion("anti-HBc = positive")
aHBs_pos = Assertion("anti-HBs = positive")
IgMaHBc_pos = Assertion("IgM anti-HBc = positive")
#Defining diagnoses
acute_infection = Diagnosis(
'Acute infecction', {
Criterion(IgMaHBc_pos, True),
Criterion(aHBs_pos, False),
Criterion(aHBc_pos, True),
Criterion(aHDV_neg, True),
Criterion(HBsAg_pos, True)
})
chronic_infection = Diagnosis(
'Chronic infecction', {
Criterion(IgMaHBc_pos, False),
Criterion(aHBs_pos, False),
Criterion(aHBc_pos, True),
Criterion(aHDV_neg, True),
Criterion(HBsAg_pos, True)
})
uncertain1 = Diagnosis(
'Uncertain configuration 1', {
def test_equal(self):
#Defining assertions
assertionA = Assertion("assertion A")
assertionB = Assertion("assertion B")
assertionC = Assertion("assertion C")
assertionD = Assertion("assertion D")
assertionE = Assertion("assertion E")
assertionX = Assertion("assertion X")
assertionY = Assertion("assertion Y")
#Defining criteria
criterionA = Criterion(assertionA, True)
criterionC = Criterion(assertionC, True)
criterionD = Criterion(assertionD, True)
criterionE = Criterion(assertionE, True)
criterionNA = Criterion(assertionA, False)
criterionNB = Criterion(assertionB, False)
criterionNC = Criterion(assertionC, False)
criterionND = Criterion(assertionD, False)
criterionNE = Criterion(assertionE, False)
criterionX = Criterion(assertionX, True)
criterionY = Criterion(assertionY, False)
#Defining diagnoses
diagnosis1 = Diagnosis('Diagnosis 1', {criterionA, criterionNB, criterionC, criterionX}, 0.2)
diagnosis2 = Diagnosis('Diagnosis 2', {criterionNA, criterionNC, criterionD, criterionY, criterionX}, 0.2)
diagnosis3 = Diagnosis('Diagnosis 3', {criterionNA, criterionC, criterionX}, 0.2)
diagnosis4 = Diagnosis('Diagnosis 4', {criterionNA, criterionNC, criterionND, criterionE, criterionX}, 0.2)
diagnosis5 = Diagnosis('Diagnosis 5', {criterionNA, criterionNC, criterionND, criterionNE, criterionX}, 0.2)
#Defining an issue
issue = Issue('Issue I', {diagnosis1, diagnosis2, diagnosis3, diagnosis4, diagnosis5})
#Building a test tree manually
#For diagnosis 1
#I->C->A->1
inode1 = Node(issue)
aCnode1 = assertionC.parent(inode1)
cCnode1 = criterionC.parent(aCnode1)
aAnode1 = assertionA.parent(cCnode1)
cAnode1 = criterionA.parent(aAnode1)
diagnosis1.parent(cAnode1)
#For diagnosis 2
#I->C->D->2
cNCnode1 = criterionNC.parent(aCnode1)
aDnode1 = assertionD.parent(cNCnode1)
cDnode1 = criterionD.parent(aDnode1)
diagnosis2.parent(cDnode1)
#For diagnosis 3
#I->C->A->3
cNAnode1 = criterionNA.parent(aAnode1)
diagnosis3.parent(cNAnode1)
#For diagnosis 4
#I->C->D->->E->4
cNDnode1 = criterionND.parent(aDnode1)
aEnode1 = assertionE.parent(cNDnode1)
cEnode1 = criterionE.parent(aEnode1)
diagnosis4.parent(cEnode1)
#For diagnosis 4
#I->C->D->->E->4
cNEnode1 = criterionNE.parent(aEnode1)
diagnosis5.parent(cNEnode1)
#Building a second test tree manually
#For diagnosis 2
#I->C->A->1
inode2 = Node(issue)
aCnode2 = assertionC.parent(inode2)
cNCnode2 = criterionNC.parent(aCnode2)
aDnode2 = assertionD.parent(cNCnode2)
cDnode2 = criterionD.parent(aDnode2)
diagnosis2.parent(cDnode2)
#For diagnosis 1
#I->C->D->2
cCnode2 = criterionC.parent(aCnode2)
aAnode2 = assertionA.parent(cCnode2)
cAnode2 = criterionA.parent(aAnode2)
diagnosis1.parent(cAnode2)
#For diagnosis 3
#I->C->A->3
cNAnode2 = criterionNA.parent(aAnode2)
diagnosis3.parent(cNAnode2)
#For diagnosis 4
#I->C->D->->E->4
cNDnode2 = criterionND.parent(aDnode2)
aEnode2 = assertionE.parent(cNDnode2)
cEnode2 = criterionE.parent(aEnode2)
diagnosis4.parent(cEnode2)
#For diagnosis 5
#I->C->D->E->5
cNEnode2 = criterionNE.parent(aEnode2)
diagnosis5.parent(cNEnode2)
#Building a third test tree manually
# Assert that the node 1 tree is equal to the node 2 tree
self.assertEqual(inode1, inode2)
from osler.issue import Issue
from osler.engine import Matrix
#Defining assertions
assertionA = Assertion("assertion A", "is assertion A true?")
assertionB = Assertion("assertion B", "is assertion B true?")
assertionC = Assertion("assertion C", "is assertion C true?")
assertionD = Assertion("assertion D", "is assertion D true?")
assertionE = Assertion("assertion E", "is assertion E true?")
assertionX = Assertion("assertion X", "is assertion X true?")
assertionY = Assertion("assertion Y", "is assertion Y true?")
#Defining criteria
criterionA = Criterion(assertionA, True)
criterionB = Criterion(assertionB, True)
criterionC = Criterion(assertionC, True)
criterionD = Criterion(assertionD, True)
criterionE = Criterion(assertionE, True)
criterionNA = Criterion(assertionA, False)
criterionNB = Criterion(assertionB, False)
criterionNC = Criterion(assertionC, False)
criterionND = Criterion(assertionD, False)
criterionNE = Criterion(assertionE, False)
criterionX = Criterion(assertionX, True)
criterionY = Criterion(assertionY, False)
#Defining diagnoses
def test_init(self):
assertionA = Assertion("assertion A", "is assertion A true?")
assertionB = Assertion("assertion B", "is assertion B true?")
assertionC = Assertion("assertion C", "is assertion C true?")
assertionX = Assertion("assertion X", "is assertion X true?")
diagnosis1 = Diagnosis(
'Diagnosis 1', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.25)
diagnosis2 = Diagnosis(
'Diagnosis 2', {
Criterion(assertionA, False),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.5)
diagnosis3 = Diagnosis(
'Diagnosis 3', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, False),
Criterion(assertionX, False)
}, 0.25)
issue = Issue("Issue name", {diagnosis1, diagnosis2, diagnosis3})
self.assertEqual(issue.name, "Issue_name")
self.assertEqual(issue.candidates,
{diagnosis1, diagnosis2, diagnosis3})
def test_init(self):
#Defining assertions
assertionA = Assertion("assertion A")
assertionB = Assertion("assertion B")
assertionC = Assertion("assertion C")
assertionD = Assertion("assertion D")
assertionE = Assertion("assertion E")
assertionX = Assertion("assertion X")
assertionY = Assertion("assertion Y")
#Defining criteria
criterionA = Criterion(assertionA, True)
criterionC = Criterion(assertionC, True)
criterionD = Criterion(assertionD, True)
criterionE = Criterion(assertionE, True)
criterionNA = Criterion(assertionA, False)
criterionNB = Criterion(assertionB, False)
criterionNC = Criterion(assertionC, False)
criterionND = Criterion(assertionD, False)
criterionNE = Criterion(assertionE, False)
criterionX = Criterion(assertionX, True)
criterionY = Criterion(assertionY, False)
#Defining diagnoses
diagnosis1 = Diagnosis(
'Diagnosis 1', {criterionA, criterionNB, criterionC, criterionX},
0.2)
diagnosis2 = Diagnosis(
'Diagnosis 2',
{criterionNA, criterionNC, criterionD, criterionY, criterionX},
0.2)
diagnosis3 = Diagnosis('Diagnosis 3',
{criterionNA, criterionC, criterionX}, 0.2)
diagnosis4 = Diagnosis(
'Diagnosis 4',
{criterionNA, criterionNC, criterionND, criterionE, criterionX},
0.2)
diagnosis5 = Diagnosis(
'Diagnosis 5',
{criterionNA, criterionNC, criterionND, criterionNE, criterionX},
0.2)
#Defining an issue
issue = Issue(
'Issue I',
{diagnosis1, diagnosis2, diagnosis3, diagnosis4, diagnosis5})
#Building a test tree using the engine
matrix = Matrix(issue)
matrix.construct_tree()
#Building a test tree manually
#For diagnosis 1
#I->C->A->1
inode = Node(issue)
aCnode = assertionC.parent(inode)
cCnode = criterionC.parent(aCnode)
aAnode = assertionA.parent(cCnode)
cAnode = criterionA.parent(aAnode)
diagnosis1.parent(cAnode)
#For diagnosis 2
#I->C->D->2
cNCnode = criterionNC.parent(aCnode)
aDnode = assertionD.parent(cNCnode)
cDnode = criterionD.parent(aDnode)
diagnosis2.parent(cDnode)
#For diagnosis 3
#I->C->A->3
cNAnode = criterionNA.parent(aAnode)
diagnosis3.parent(cNAnode)
#For diagnosis 4
#I->C->D->->E->4
cNDnode = criterionND.parent(aDnode)
aEnode = assertionE.parent(cNDnode)
cEnode = criterionE.parent(aEnode)
diagnosis4.parent(cEnode)
#For diagnosis 4
#I->C->D->->E->4
cNEnode = criterionNE.parent(aEnode)
diagnosis5.parent(cNEnode)
# Assert that the manually-generated tree is equal to the engine-generated tree
self.assertEqual(matrix.node, inode)
def test_diagnosable(self):
assertionA = Assertion("assertion A")
assertionB = Assertion("assertion B")
assertionC = Assertion("assertion C")
assertionX = Assertion("assertion X")
diagnosis1 = Diagnosis(
'Diagnosis 1', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.25)
diagnosis2 = Diagnosis(
'Diagnosis 2', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.5)
diagnosis3 = Diagnosis(
'Diagnosis 3', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, False),
Criterion(assertionX, False)
}, 0.25)
self.assertTrue(diagnosable({diagnosis1, diagnosis3}))
self.assertFalse(diagnosable({diagnosis1, diagnosis2}))
def test_equality(self):
assertionA = Assertion("assertion A")
assertionB = Assertion("assertion B")
assertionC = Assertion("assertion C")
assertionX = Assertion("assertion X")
diagnosis1 = Diagnosis(
'Diagnosis 1', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.25)
diagnosis2 = Diagnosis(
'Diagnosis 2', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, True),
Criterion(assertionX, False)
}, 0.5)
diagnosis3 = Diagnosis(
'Diagnosis 1', {
Criterion(assertionA, True),
Criterion(assertionB, False),
Criterion(assertionC, False),
Criterion(assertionX, False)
}, 0.25)
self.assertTrue(diagnosis1 == diagnosis2)
self.assertFalse(diagnosis1 == diagnosis3)