def setUp(self):
testNS = {
'med' : 'http://ts.tno.nl/mediator/1.0/',
't' : 'http://ts.tno.nl/mediator/test#',
'dc' : 'http://purl.org/dc/elements/1.1/',
'ne' : 'http://ts.tno.nl/mediator/1.0/examples/NonExistent/',
'oa' : 'http://tutorial.topbraid.com/ontoA/',
'edoal' : 'http://ns.inria.org/edoal/1.0/#'
}
self.base = 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#'
self.nsMgr = NSManager(testNS, self.base)
self.c = PT.Correspondence(nsMgr=self.nsMgr)
self.operands = []
self.testCases = {}
'''
The Transform tests will validate:
* testTransformation: the creation of a transformation specification
* testMakeTransform: the transition from the name of an operation to a callable function
* testTransform: the transition from the specification of the operands to the inclusion of the correct values in the operation
'''
alignFile = "resources/alignPassTransformation1.xml"
self.align = EDOALparser.Alignment(alignFile, self.nsMgr)
if self.align == None: raise TestException("Cannot find an alignment in file '{}'".format(alignFile))
self.corrs = self.align._align.findall(str(self.nsMgr.asClarks(':map')) + '/' + str(self.nsMgr.asClarks(':Cell')))
if self.corrs == None or self.corrs == []: raise TestException("Cannot find <map><Cell> elements in file '{}'".format(alignFile))
self.Transformations = []
for corr in self.corrs:
TransformationElmnts = corr.findall(str(self.nsMgr.asClarks('edoal:transformation')) + '/' + str(self.nsMgr.asClarks('edoal:Transformation')))
if TransformationElmnts == None or TransformationElmnts == []: raise TestException("Cannot find <transformation><Transformation> elements in file '{}'".format(alignFile))
self.Transformations += TransformationElmnts
print('Testcase: {}'.format(self.__class__.__name__))
def setUp(self):
testNS = {
'med': 'http://ds.tno.nl/mediator/1.0/',
'dc': 'http://purl.org/dc/elements/1.1/',
'edoal': 'http://ns.inria.org/edoal/1.0/#',
'test': 'http://ds.tno.nl/mediator/1.0'
}
self.base = 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#'
self.nsMgr = NSManager(nsDict=testNS, base=self.base)
def setUp(self):
testNS = {
'med' : 'http://ds.tno.nl/mediator/1.0/',
'dc' : 'http://purl.org/dc/elements/1.1/',
'edoal' : 'http://ns.inria.org/edoal/1.0/#'
}
self.base = 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#'
self.nsMgr = NSManager(testNS, self.base)
self.c = PT.Correspondence(nsMgr=self.nsMgr)
print('Testcase: {}'.format(self.__class__.__name__))
def setUp(self):
testNS = {
'med' : 'http://ts.tno.nl/mediator/1.0/',
'dc' : 'http://purl.org/dc/elements/1.1/',
'edoal' : 'http://ns.inria.org/edoal/1.0/#'
}
self.base = 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#'
self.nsMgr = NSManager(testNS, self.base)
self.path = PT.Path()
self.property = PT.EProperty(entity_iri='med:testProperty', nsMgr=self.nsMgr)
self.relations = [PT.ERelation(entity_iri='med:testRel1', nsMgr=self.nsMgr), PT.ERelation(entity_iri='med:testRel2', nsMgr=self.nsMgr), PT.ERelation(entity_iri='med:testRel3', nsMgr=self.nsMgr)]
print('Testcase: {}'.format(self.__class__.__name__))
def addEntityExpr(self, ent_expr=None):
assert isinstance(
ent_expr, EntityExpression
) and ent_expr != "", "Entity expression expected, got {}".format(
type(ent_expr))
assert len(
self.getEntities()
) < 2, "Entity constructions containing more than 2 entity expressions are not allowed (although it would remove recursion)"
assert NSManager.isIRI(
ent_expr.getIriRef()
), "Cannot add invalid iri as ent_expr to ent_expr construction, got {}".format(
ent_expr.getIriRef())
self._entities.append(ent_expr)
class transformTest(unittest.TestCase):
def setUp(self):
testNS = {
'med' : 'http://ts.tno.nl/mediator/1.0/',
't' : 'http://ts.tno.nl/mediator/test#',
'dc' : 'http://purl.org/dc/elements/1.1/',
'ne' : 'http://ts.tno.nl/mediator/1.0/examples/NonExistent/',
'oa' : 'http://tutorial.topbraid.com/ontoA/',
'edoal' : 'http://ns.inria.org/edoal/1.0/#'
}
self.base = 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#'
self.nsMgr = NSManager(testNS, self.base)
self.c = PT.Correspondence(nsMgr=self.nsMgr)
self.operands = []
self.testCases = {}
'''
The Transform tests will validate:
* testTransformation: the creation of a transformation specification
* testMakeTransform: the transition from the name of an operation to a callable function
* testTransform: the transition from the specification of the operands to the inclusion of the correct values in the operation
'''
alignFile = "resources/alignPassTransformation1.xml"
self.align = EDOALparser.Alignment(alignFile, self.nsMgr)
if self.align == None: raise TestException("Cannot find an alignment in file '{}'".format(alignFile))
self.corrs = self.align._align.findall(str(self.nsMgr.asClarks(':map')) + '/' + str(self.nsMgr.asClarks(':Cell')))
if self.corrs == None or self.corrs == []: raise TestException("Cannot find <map><Cell> elements in file '{}'".format(alignFile))
self.Transformations = []
for corr in self.corrs:
TransformationElmnts = corr.findall(str(self.nsMgr.asClarks('edoal:transformation')) + '/' + str(self.nsMgr.asClarks('edoal:Transformation')))
if TransformationElmnts == None or TransformationElmnts == []: raise TestException("Cannot find <transformation><Transformation> elements in file '{}'".format(alignFile))
self.Transformations += TransformationElmnts
print('Testcase: {}'.format(self.__class__.__name__))
def tearDown(self):
pass
def testTransformation(self):
# Test the connection to, and correct execution of, a predefined python method
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
from transformations import unitconversion
# setup specifics
oneOperands = []
t = self.Transformations[0]
operandEl = t.find(str(self.nsMgr.asClarks('edoal:entity1')))
if operandEl == None: raise TestException("Cannot find <edoal:entity1> element in <edoal:Transformation> ")
oneOperands.append(self.align.Value(el=operandEl, parse_alignment=self.align))
twoOperands = []
operandEl = t.find(str(self.nsMgr.asClarks('edoal:entity2')) + '/' + str(self.nsMgr.asClarks('edoal:Apply')) + '/' + str(self.nsMgr.asClarks('edoal:arguments')))
if operandEl == None: raise TestException("Cannot find <edoal:entity2><edoal:Apply><edoal:arguments> element in <edoal:Transformation> ")
for value_el in operandEl.iter():
if value_el.tag == self.nsMgr.asClarks('edoal:Literal'):
twoOperands.append(self.align.Value(el=value_el, parse_alignment=self.align))
# PASS tests
# First test: init a complete transformation
assert 'FtoC' in dir(unitconversion)
t = PT.Transformation(python_module='unitconversion', method_name='FtoC', operands=oneOperands)
assert t != None, "Failed to make a Transformation"
print(".", end="")
assert t.getLocalMethod()[1] == 'FtoC', "Expected {}, got {}".format('FtoC', t.getLocalMethod()[1])
print(".", end="")
assert t.getLocalMethod()[0].__name__ == 'transformations.unitconversion', "Expected {}, got {}".format('transformations.unitconversion', t.getLocalMethod()[0].__name__)
print(".", end="")
assert t._operands == oneOperands, "Failed to register operands: expected {}, got {}".format(oneOperands, t._operands)
print(".", end="")
args = '32'
assert t.getOperationResult(args) == decimal.Decimal('0'), "Expected {} as transformation result, got {}".format(decimal.Decimal('0'), t.getOperationResult(value=args))
print(".", end="")
# Second test: init an empty transformation, and add the elements
assert 'CtoF' in dir(unitconversion)
t = PT.Transformation()
assert t != None, "Failed to make an empty Transformation"
print(".", end="")
t.registerLocalMethod(python_module='unitconversion', method_name='CtoF')
assert t.getLocalMethod()[1] == 'CtoF', "Failed to register local method: Expected {}, got {}".format('CtoF', t.getLocalMethod()[1])
print(".", end="")
assert t.getLocalMethod()[0].__name__ == 'transformations.unitconversion', "Failed to register local method: Expected {}, got {}".format('transformations.unitconversion', t.getLocalMethod()[0].__name__)
print(".", end="")
t.registerOperands(operands=oneOperands)
assert t._operands == oneOperands, "Failed to register operands: expected {}, got {}".format(oneOperands, t._operands)
print(".", end="")
assert t.getOperationResult('0') == decimal.Decimal('32'), "Expected {} as transformation result, got {}".format(decimal.Decimal('32'), t.getOperationResult(value='0'))
print(".", end="")
# Third test: init a partially empty transformation, and add two operands
assert 'TempConvertor' in dir(unitconversion)
t = PT.Transformation(python_module='unitconversion', method_name='TempConvertor')
assert t != None, "Failed to make an partly empty Transformation"
print(".", end="")
assert t.getLocalMethod()[1] == 'TempConvertor', "Failed to register local method: Expected {}, got {}".format('CtoF', t.getLocalMethod()[1])
print(".", end="")
assert t.getLocalMethod()[0].__name__ == 'transformations.unitconversion', "Failed to register local method: Expected {}, got {}".format('transformations.unitconversion', t.getLocalMethod()[0].__name__)
print(".", end="")
t.registerOperands(operands=twoOperands)
assert t._operands == twoOperands, "Failed to register operands: expected {}, got {}".format(twoOperands, t._operands)
print(".", end="")
assert t.getOperationResult(temp_value='0', src_unit='c', tgt_unit='f') == decimal.Decimal('32'), "Expected {} as transformation result, got {}".format(decimal.Decimal('32'), t.getOperationResult(temp_value='0', src_unit='f', tgt_unit='c'))
print(".", end="")
# Fail scenarios
with self.assertRaises(AssertionError):
PT.Transformation(python_module='unitconversion', method_name='CtoF', operands=['InvalidOperand'])
print(".", end="")
with self.assertRaises(AssertionError):
PT.Transformation(python_module='unitconversion', method_name='appelepap', operands=oneOperands)
print(".", end="")
with self.assertRaises(AssertionError):
PT.Transformation(python_module='appelepap', method_name='FtoC', operands=oneOperands)
print(". done")
def testMakeTransform(self):
# Success scenarios
# Test the creation of a callable transformation
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
t = PT.Transformation(python_module='unitconversion', method_name='FtoC', operands=self.operands)
t.makeTransform(resultIRI='newIRI')
assert callable(t.transform), "Expected callable function, but {} is not callable".format(t.transform)
print(".", end="")
assert t.getOperationResult('32') == decimal.Decimal('0'), "Expected {} as transformation result, got {}".format(decimal.Decimal('0'), t.getOperationResult('32'))
print(".", end="")
# Fail scenarios
t = PT.Transformation(operands=self.operands)
with self.assertRaises(AssertionError):
t.makeTransform(resultIRI='newIRI')
print(".", end="")
t = PT.Transformation(python_module='unitconversion', operands=self.operands)
with self.assertRaises(AssertionError):
_ = t.makeTransform(resultIRI='newIRI')
print(".", end="")
t = PT.Transformation(method_name='FtoC', operands=self.operands)
with self.assertRaises(AssertionError):
_ = t.makeTransform(resultIRI='newIRI')
print(". done")
class correspondenceTest(unittest.TestCase):
def setUp(self):
testNS = {
'med' : 'http://ds.tno.nl/mediator/1.0/',
'dc' : 'http://purl.org/dc/elements/1.1/',
'edoal' : 'http://ns.inria.org/edoal/1.0/#'
}
self.base = 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#'
self.nsMgr = NSManager(testNS, self.base)
self.c = PT.Correspondence(nsMgr=self.nsMgr)
print('Testcase: {}'.format(self.__class__.__name__))
def tearDown(self):
pass
def testSetName(self):
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
# Success scenarios
self.c.setName(name="appelepap")
assert self.c.getName() == "appelepap", "Assertion error, got {}".format(self.c.getName())
self.c.setName(name="unknownPF:appelepap")
assert self.c.getName() == "unknownPF:appelepap", "Assertion error, got {}".format(self.c.getName())
print(".", end="")
# Failure scenarios
with self.assertRaises(AssertionError):
self.c.setName(name="")
with self.assertRaises(AssertionError):
self.c.setName(name=12)
with self.assertRaises(AssertionError):
self.c.setName(name=True)
with self.assertRaises(AssertionError):
self.c.setName(name=False)
with self.assertRaises(AssertionError):
self.c.setName(name=None)
print(". done")
def testEntity(self):
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
count = 0
N = 4 + 4
# Success scenarios
for e_type in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP'], PT.Alignment.EDOAL['INST']]:
count += 1
# Success scenarios, QName with prefix
testEnt = PT._Entity(entity_iri="med:appelepap", entity_type=e_type, nsMgr=self.nsMgr)
exp_iri = "<http://ds.tno.nl/mediator/1.0/appelepap>"
assert testEnt.getIriRef() == exp_iri, "Testfault: got '{}', expected '{}'.".format(testEnt.getIriRef(), exp_iri)
assert testEnt.getType() == e_type, "Testfault: got '{}', expected '{}'.".format(testEnt.getType(), e_type)
# Success scenarios, QName without prefix
testEnt = PT._Entity(entity_iri=":appelepap", entity_type=e_type, nsMgr=self.nsMgr)
exp_iri = "<" + self.base + "appelepap>"
assert testEnt.getIriRef() == exp_iri and testEnt.getType() == e_type
# Success scenarios, with correct IRI
testEnt = PT._Entity(entity_iri="http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear", entity_type=e_type, nsMgr=self.nsMgr)
exp_iri = "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"
assert testEnt.getIriRef() == exp_iri, "Testfault: got '{}', expected '{}'.".format(testEnt.getIriRef(), exp_iri)
assert testEnt.getType() == e_type, "Testfault: got '{}', expected '{}'.".format(testEnt.getType(), e_type)
# Success scenarios, with correct <IRI>
testEnt = PT._Entity(entity_iri="<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>", entity_type=e_type, nsMgr=self.nsMgr)
exp_iri = "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"
assert testEnt.getIriRef() == exp_iri, "Testfault: got '{}', expected '{}'.".format(testEnt.getIriRef(), exp_iri)
assert testEnt.getType() == e_type, "Testfault: got '{}', expected '{}'.".format(testEnt.getType(), e_type)
# Success scenarios, with correct Clark's notation
testEnt = PT._Entity(entity_iri="{http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#}VintageYear", entity_type=e_type, nsMgr=self.nsMgr)
exp_iri = "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"
assert testEnt.getIriRef() == exp_iri, "Testfault: got '{}', expected '{}'.".format(testEnt.getIriRef(), exp_iri)
assert testEnt.getType() == e_type, "Testfault: expected '{}', got '{}'.".format(testEnt.getType(), e_type)
print(".", end="")
# Failure scenarios
for e_type in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP'], PT.Alignment.EDOAL['INST']]:
count += 1
with self.assertRaises(RuntimeError):
testEnt = PT._Entity(entity_iri=":^_invalidIriChar", entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(RuntimeError):
testEnt = PT._Entity(entity_iri=":!_invalidIriChar", entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(RuntimeError):
testEnt = PT._Entity(entity_iri="^_invalidIriChar", entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
testEnt = PT._Entity(entity_iri="", entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(RuntimeError):
testEnt = PT._Entity(entity_iri="unknownPF:appelepap", entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(RuntimeError):
testEnt = PT._Entity(entity_iri="noPFOrAnythingWhatsoever", entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
testEnt = PT._Entity(entity_iri=12, entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
testEnt = PT._Entity(entity_iri=12.3, entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
testEnt = PT._Entity(entity_iri=True, entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
testEnt = PT._Entity(entity_iri=False, entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
testEnt = PT._Entity(entity_iri=None, entity_type=e_type, nsMgr=self.nsMgr)
print(".", end="")
assert count == N, "Didn't test everything, expected {} tests, done only {}".format(N, count)
print(". done")
def testConstruction(self):
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
count = 0
N = 3 + 3 * 3 + 4 + 4
# Mixed success and failure scenarios
for e_type1 in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP']]:
count += 1
testEnt1 = PT._Entity(entity_iri="med:appelepap", entity_type=e_type1, nsMgr=self.nsMgr)
# Success scenario - unary operation
constr = PT.Neg(testEnt1)
assert constr.getCType() == PT._EntityConstruction.NOTSYMBOL, "Testfault: expected '{}', got '{}'.".format(PT._EntityConstruction.NOTSYMBOL, constr.getCType())
print(".", end="")
# Binary operation scenarios
for e_type2 in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP']]:
testEnt2 = PT._Entity(entity_iri="med:appelepap", entity_type=e_type2, nsMgr=self.nsMgr)
if e_type1 == e_type2:
# Success scenario - binary operations
count += 1
constr = PT.Union(testEnt1, testEnt2)
assert constr.getCType() == PT._EntityConstruction.SQRUNION, "Testfault: expected '{}', got '{}'.".format(PT._EntityConstruction.SQRUNION, constr.getCType())
constr = PT.Intersection(testEnt1, testEnt2)
assert constr.getCType() == PT._EntityConstruction.SQRINTSCT, "Testfault: expected '{}', got '{}'.".format(PT._EntityConstruction.SQRINTSCT, constr.getCType())
print(".", end="")
else:
# Failure scenario - binary operations
count += 1
with self.assertRaises(AssertionError):
constr = PT.Union(testEnt1, testEnt2)
print(".", end="")
# Failure scenarios
testEnt1 = PT._Entity(entity_iri="med:appelepap", entity_type=PT.Alignment.EDOAL['INST'], nsMgr=self.nsMgr)
for e_type in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP'], PT.Alignment.EDOAL['INST']]:
count += 1
testEnt2 = PT._Entity(entity_iri="med:appelepap", entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
constr = PT.Union(testEnt1, testEnt2)
print(".", end="")
testEnt2 = PT._Entity(entity_iri="med:appelepap", entity_type=PT.Alignment.EDOAL['INST'], nsMgr=self.nsMgr)
for e_type in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP'], PT.Alignment.EDOAL['INST']]:
count += 1
testEnt1 = PT._Entity(entity_iri="med:appelepap", entity_type=e_type, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
constr = PT.Union(testEnt1, testEnt2)
print(".", end="")
assert count == N, "Didn't test everything, expected {} tests, done only {}".format(N, count)
print(". done")
def testSetSrcEE(self):
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
count = 0
N = 4 * 4 + 3 * 4 + 4
# Success scenarios; entity_expr of type _Entity
for e_type in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP'], PT.Alignment.EDOAL['INST']]:
for test_iri in ["med:appelepap", ":appelepap", "http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear", "{http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#}VintageYear"]:
count += 1
testEnt = PT._Entity(entity_iri=test_iri, entity_type=e_type, nsMgr=self.nsMgr)
self.c.setEE1(entity_expr=testEnt)
assert self.c.getEE1().getIriRef() == self.nsMgr.asIRI(test_iri), "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getIriRef(), self.nsMgr.asIRI(test_iri))
assert self.c.getEE1().getType() == e_type, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getType(), e_type)
print(".", end="")
if e_type != PT.Alignment.EDOAL['INST']:
count += 1
# Success scenarios; entity_expr of type _EntityConstruction
testEnt2 = PT._Entity(entity_iri="med:perenmoes", entity_type=e_type, nsMgr=self.nsMgr)
constr = PT.Union(testEnt, testEnt2)
self.c.setEE1(entity_expr=constr)
assert self.c.getEE1().getCType() == PT._EntityConstruction.SQRUNION, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getCType(), PT._EntityConstruction.SQRUNION)
assert self.c.getEE1().getEntType() == e_type, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getEntType(), e_type)
assert self.c.getEE1().getEntities()[0] == testEnt, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getEntities()[0], testEnt)
assert self.c.getEE1().getEntities()[1] == testEnt2, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getEntities()[1], testEnt2)
constr = PT.Intersection(testEnt, testEnt2)
self.c.setEE1(entity_expr=constr)
assert self.c.getEE1().getCType() == PT._EntityConstruction.SQRINTSCT, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getCType(), PT._EntityConstruction.SQRINTSCT)
assert self.c.getEE1().getEntType() == e_type, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getEntType(), e_type)
assert self.c.getEE1().getEntities()[0] == testEnt, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getEntities()[0], testEnt)
assert self.c.getEE1().getEntities()[1] == testEnt2, "Testfault: got '{}', expected '{}'.".format(self.c.getEE1().getEntities()[1], testEnt2)
print(".", end="")
# Failure scenarios
for e_type in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP'], PT.Alignment.EDOAL['INST']]:
count += 1
with self.assertRaises(AssertionError):
self.c.setEE1(entity_expr="wrong type")
with self.assertRaises(AssertionError):
self.c.setEE1(entity_expr=12)
with self.assertRaises(AssertionError):
self.c.setEE1(entity_expr=12.3)
with self.assertRaises(AssertionError):
self.c.setEE1(entity_expr=True)
with self.assertRaises(AssertionError):
self.c.setEE1(entity_expr=None)
print(".", end="")
assert count == N, "Didn't test everything, expected {} tests, done only {}".format(N, count)
print(". done")
def testSetTgtEE(self):
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
count = 0
N = 4 * 4 + 3 * 4 + 4
# Success scenarios; entity_expr of type _Entity
for e_type in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP'], PT.Alignment.EDOAL['INST']]:
for test_iri in ["med:appelepap", ":appelepap", "http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear", "{http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#}VintageYear"]:
count += 1
testEnt = PT._Entity(entity_iri=test_iri, entity_type=e_type, nsMgr=self.nsMgr)
self.c.setEE2(entity_expr=testEnt)
assert self.c.getEE2().getIriRef() == self.nsMgr.asIRI(test_iri), "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getIriRef(), self.nsMgr.asIRI(test_iri))
assert self.c.getEE2().getType() == e_type, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getType(), e_type)
print(".", end="")
if e_type != PT.Alignment.EDOAL['INST']:
# Success scenarios; entity_expr of type _EntityConstruction
count += 1
testEnt2 = PT._Entity(entity_iri="med:perenmoes", entity_type=e_type, nsMgr=self.nsMgr)
constr = PT.Union(testEnt, testEnt2)
self.c.setEE2(entity_expr=constr)
assert self.c.getEE2().getCType() == PT._EntityConstruction.SQRUNION, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getCType(), PT._EntityConstruction.SQRUNION)
assert self.c.getEE2().getEntType() == e_type, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getEntType(), e_type)
assert self.c.getEE2().getEntities()[0] == testEnt, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getEntities()[0], testEnt)
assert self.c.getEE2().getEntities()[1] == testEnt2, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getEntities()[1], testEnt2)
constr = PT.Intersection(testEnt, testEnt2)
self.c.setEE2(entity_expr=constr)
assert self.c.getEE2().getCType() == PT._EntityConstruction.SQRINTSCT, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getCType(), PT._EntityConstruction.SQRINTSCT)
assert self.c.getEE2().getEntType() == e_type, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getEntType(), e_type)
assert self.c.getEE2().getEntities()[0] == testEnt, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getEntities()[0], testEnt)
assert self.c.getEE2().getEntities()[1] == testEnt2, "Testfault: got '{}', expected '{}'.".format(self.c.getEE2().getEntities()[1], testEnt2)
print(".", end="")
# Failure scenarios
for e_type in [PT.Alignment.EDOAL['CLASS'], PT.Alignment.EDOAL['RELN'], PT.Alignment.EDOAL['PROP'], PT.Alignment.EDOAL['INST']]:
count += 1
with self.assertRaises(AssertionError):
self.c.setEE2(entity_expr="wrong type")
with self.assertRaises(AssertionError):
self.c.setEE2(entity_expr=12)
with self.assertRaises(AssertionError):
self.c.setEE2(entity_expr=12.3)
with self.assertRaises(AssertionError):
self.c.setEE2(entity_expr=True)
with self.assertRaises(AssertionError):
self.c.setEE2(entity_expr=None)
print(".", end="")
assert count == N, "Didn't test everything, expected {} tests, done only {}".format(N, count)
print(". done")
def testSetCorrRelation(self):
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
count = 0
N = 5
# Success scenarios
for rel in [PT.MEDRELEQ, PT.MEDRELSUB, PT.MEDRELSUP, PT.MEDRELIN, PT.MEDRELNI]:
count += 1
self.c.setCorrRelation(relation=rel)
assert self.c.getCorrRelation() == rel
print(".", end="")
# Failure scenarios
with self.assertRaises(AssertionError):
self.c.setCorrRelation(relation=None)
with self.assertRaises(AssertionError):
self.c.setCorrRelation(relation=12)
with self.assertRaises(AssertionError):
self.c.setCorrRelation(relation="appelepap")
with self.assertRaises(AssertionError):
self.c.setCorrRelation(relation=True)
with self.assertRaises(AssertionError):
self.c.setCorrRelation(relation=False)
assert count == N, "Didn't test everything, expected {} tests, done only {}".format(N, count)
print(". done")
def testSetCorrMeasure(self):
print('\tTesting {} '.format(inspect.currentframe().f_code.co_name), end="")
count = 0
N = 6 + 8
# Success scenarios
for val, tpe in [(0.01, self.nsMgr.asIRI('xsd:float')), ('medium', self.nsMgr.asIRI('xsd:string')), (0.0, self.nsMgr.asIRI('xsd:double')), (1.0, self.nsMgr.asIRI('xsd:float')), (0, self.nsMgr.asIRI('xsd:decimal')), (1, self.nsMgr.asIRI('xsd:integer'))]:
count += 1
self.c.setCorrMeasure(measure=val, measure_type=tpe)
assert (val, tpe) == self.c.getCorrMeasure()
print(".", end="")
# Failure scenarios - no check exist yet for incoherence between measure and measure_type, e.g., (0.42, xsd:integer), or ('appelepap', xsd:float)
for val, tpe in [(0.01, ''), (None, self.nsMgr.asIRI('xsd:float')), (None, None), ('', None), (None, ''), ('', ''), (-0.1, self.nsMgr.asIRI('xsd:float')), (12, self.nsMgr.asIRI('xsd:integer'))]:
count += 1
with self.assertRaises(AssertionError):
self.c.setCorrMeasure(measure=val, measure_type=tpe)
print(".", end="")
assert count == N, "Didn't test everything, expected {} tests, done only {}".format(N, count)
print(". done")
def setUp(self):
# from mediator.EDOALparser import Alignment
ns = {'rdf' : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
'xsd' : "http://www.w3.org/2001/XMLSchema#",
'align':"http://knowledgeweb.semanticweb.org/heterogeneity/alignment#",
'dc' : 'http://purl.org/dc/elements/1.1/',
'edoal':'http://ns.inria.org/edoal/1.0/#',
'alext': 'http://exmo.inrialpes.fr/align/ext/1.0/',
'medtfn': 'http://ts.tno.nl/mediator/1.0/transformations#',
't' : 'http://ts.tno.nl/mediator/test#'
}
self.nsMgr = NSManager(ns, "http://knowledgeweb.semanticweb.org/heterogeneity/alignment#")
print(str(self.nsMgr))
self.testCases = {}
# Edoal parsing tests
'''
The admin tests will check the edoal Alignment element (refer to http://alignapi.gforge.inria.fr/format.html), however, restricted to:
* <xml>: (value: "yes"/"no") indicates if the alignment can be read as an XML file compliant with the DTD;
* <level>: (values: "0", "1", "2EDOAL") the level of alignment, characterising its type;
* <type>: (values: "11"/"1?"/"1+"/"1*"/"?1"/"??"/"?+"/"?*"/"+1"/"+?"/"++"/"+*"/"*1"/"*?"/"?+"/"**"; default "11")
This represents the arity of alignment. Usual notations are 1:1, 1:m, n:1 or n:m. We prefer to note if the mapping is injective,
surjective and total, or partial on both sides. We then end up with more alignment arities:
. 1 for injective and total,
. ? for injective,
. + for total and
. * for none
and each sign concerning one mapping and its converse;
* <onto1> and <onto2>: (value: Ontology) the source and target ontologies that are being aligned;
'''
self.testCases['ADMIN'] = []
self.testCases['ADMIN'].append(
{
'pass': {'resources/alignPassSimple0.xml': # Simple Class-EQ-Class, Prop-EQ-Prop, Reln-EQ-Reln
{'about': 'http://ds.tno.nl/ontoA-ontoB/CPR-EQ-CPR',
'admin': ['yes', 'PaulBrandt', '2015/08/25', 'manual', 'TEST DATA (simple alignments)', '2EDOAL', '?*'],
'ontoS': ["<http://tutorial.topbraid.com/ontoA#>", None, "<http://www.w3.org/2002/07/owl#>", "OWL1.0"],
'ontoT': ["<http://tutorial.topbraid.com/ontoB#>", "resources/nl/test1/ontoB.xml", "<http://www.w3.org/2002/07/owl#>", "OWL1.0"]
},
'resources/wine_align.xml': # Simple Class-EQ-Class, Prop-EQ-Prop, Reln-LT-Reln,
{'about': 'http://oms.omwg.org/wine-vin/', # & one SmplSrcCls-EQ-CmplxTgtCls, one CmpxlSrcCls-LT-CmplxTgtCls
'admin': ['yes', 'http://www.scharffe.fr/foaf.rdf', '2006/06/07', 'manual', 'TESTcase: hugely adapted from original wine-vin example', '2EDOAL', '**'],
'ontoS': ["<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#>", None, "<http://www.w3.org/TR/owl-guide/>", "owl"],
'ontoT': ["<http://ontology.deri.org/vin#>", "http://www.scharffe.fr/ontologies/OntologieDuVin.wsml", "<http://www.wsmo.org/wsml/wsml-syntax/wsml-dl>", "wsml"]
}
},
'fail':
[
['resources/alignFail0A.xml', RuntimeError], # Missing <Alignment> element
['resources/alignFail0B.xml', ValueError], # Missing 'alignET:about="somename"' in <Alignment > element
['resources/alignFail1A.xml', NotImplementedError], # Incorrect value for <Level> element: 2EDOAL expected
['resources/alignFail1B.xml', RuntimeError], # Missing <Level> element
['resources/alignFail2A.xml', RuntimeError], # Missing <type> element
['resources/alignFail2B.xml', ValueError], # Illegal value for <Level> element
['', AssertionError], # Missing file name
['resources/missingAlignFile.xml', AssertionError], # Illegal file name
]
}
)
'''
The Correspondence tests will check the edoal set of correspondences (the <Cell> elements; refer to http://alignapi.gforge.inria.fr/edoal.html), however, restricted to:
* <Cell {rdf:about=" URI "} />
* <entity1> entity </entity1>
* <entity2> entity </entity2>
* <relation> STRING </relation>
* <measure> STRING </measure>
These are all required elements
'''
self.testCases['CORR'] = []
self.testCases['CORR'].append(
{
'pass': {
'resources/alignPassSimple0.xml': { # Simple Class-EQ-Class, Prop-EQ-Prop, Reln-EQ-Reln
'corrs': [
{
'name' : "MappingRule_0",
'ent1' : {'et': Alignment.EDOAL['CLASS'], 'eir' : "<http://tutorial.topbraid.com/ontoA#unEquivanox>"},
'ent2' : {'et': Alignment.EDOAL['CLASS'], 'eir' : "<http://tutorial.topbraid.com/ontoB#OneEq>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_1",
'ent1' : {'et': Alignment.EDOAL['PROP'], 'eir' : "<http://tutorial.topbraid.com/ontoA#unEquivanox>"},
'ent2' : {'et': Alignment.EDOAL['PROP'], 'eir' : "<http://tutorial.topbraid.com/ontoB#OneEq>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_2",
'ent1' : {'et': Alignment.EDOAL['RELN'], 'eir' : "<http://tutorial.topbraid.com/ontoA#unEquivanox>"},
'ent2' : {'et': Alignment.EDOAL['RELN'], 'eir' : "<http://tutorial.topbraid.com/ontoB#OneEq>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_3",
'ent1' : {'et': Alignment.EDOAL['INST'], 'eir' : "<http://tutorial.topbraid.com/ontoA#unEquivanox>"},
'ent2' : {'et': Alignment.EDOAL['INST'], 'eir' : "<http://tutorial.topbraid.com/ontoB#OneEq>"},
'msre' : 1.0,
'reln' : 'EQ'
}
]
},
'resources/wine_align.xml': { # Simple Class-EQ-Class, Prop-EQ-Prop, Reln-LT-Reln,
'corrs': [
{
'name' : "MappingRule_0",
'ent1' : {'et': Alignment.EDOAL['CLASS'], 'eir' : "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"},
'ent2' : {'et': Alignment.EDOAL['CLASS'], 'eir' : "<http://ontology.deri.org/vin#Millesime>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_1",
'ent1' : {'et': Alignment.EDOAL['PROP'], 'eir' : "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"},
'ent2' : {'et': Alignment.EDOAL['PROP'], 'eir' : "<http://ontology.deri.org/vin#Millesime>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_2",
'ent1' : {'et': Alignment.EDOAL['RELN'], 'eir' : "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"},
'ent2' : {'et': Alignment.EDOAL['RELN'], 'eir' : "<http://ontology.deri.org/vin#Millesime>"},
'msre' : 1.0,
'reln' : 'EQ'
}
]
}
},
'fail': { # TODO: zet geen testdata in de edoal data, maar maak aparte 'fail'labels: 'AssertionErrors'
'resources/alignFail3A.xml': {
"MissingMap": RuntimeError}, # Missing <map><Cell>...</Cell></map> element
'resources/alignFail3B.xml': {
"MissingCell": RuntimeError}, # Missing <Cell> element
'resources/alignFail3C.xml': {
"MappingRule_0": AssertionError, # Empty <Cell> element
"MappingRule_1": AssertionError, # Missing <entity1> element
"MappingRule_11": AssertionError, # Multiple <entity1> element
"MappingRule_12": AssertionError, # Non-empty simple <class> element
"MappingRule_13": AssertionError, # Non-empty simple <property> element
"MappingRule_14": AssertionError, # Non-empty simple <relation> element
"MappingRule_15": AssertionError, # Non-empty simple <class> element
"MappingRule_16": AssertionError, # Non-empty simple <property> element
"MappingRule_17": AssertionError, # Non-empty simple <relation> element
"MappingRule_2": AssertionError, # Missing <entity2> element
"MappingRule_21": AssertionError, # Multiple <entity2> element
"MappingRule_3": RuntimeError, # Missing <relation> element
"MappingRule_31": RuntimeError, # Multiple <relation> element
"MappingRule_32": RuntimeError, # Illegal <relation> element
"MappingRule_4": RuntimeError, # Missing <measure> element
"MappingRule_41": RuntimeError, # Multiple <measure> element
"MappingRule_42": RuntimeError, # Missing About attribute in <measure> element
"MappingRule_5": AssertionError, # Missing About attribute in empty EDOAL element
"MappingRule_6": AssertionError, # Empty <entity> element
"MappingRule_7": AssertionError, # Unknown entity element in entity
"MappingRule_8": AssertionError # Unknown cell element in entity
}
}
}
)
'''
A Value expression is a rather central element in the EDAOL alginment. Therefore we designed a separate test for it.
BNF definition is (refer to http://alignapi.gforge.inria.fr/edoal.html):
<value> value </value>
value ::= <Literal {edoal:type=" URI "} edoal:string=" STRING " />
| instexpr
| attrexpr
| <Apply edoal:operator=" URI "> <arguments rdf:parseType="Collection">value*</arguments> </Apply>
| <Aggregate edoal:operator=" URI "> <arguments rdf:parseType="Collection">value*</arguments> </Aggregate>
instexpr ::= <Instance rdf:about=" URI "/>
attexpr ::= propexpr | relexpr
'''
self.testCases['VALUE'] = []
self.testCases['VALUE'].append(
{
'pass': {
# The LiteralPass1 tests are all <Literal>'s, but not all possible literal values/xsd:valuetype's have been specified and hence, tested
'resources/valueSimplePass1.xml': {
'valueLiteralePass1A': {
'valueType': 'edoal:Literal',
'value': 'appelepap',
'type': '<http://www.w3.org/2001/XMLSchema#string>'
},
'valueLiteralePass1B': {
'valueType': 'edoal:Literal',
'value': '123',
'type': '<http://www.w3.org/2001/XMLSchema#integer>'
},
'valueLiteralePass1C': {
'valueType': 'edoal:Literal',
'value': '1.23',
'type': '<http://www.w3.org/2001/XMLSchema#float>'
},
'valueInstancePass1': {
'valueType': 'edoal:Instance',
'value': '<http://ts.tno.nl/mediator/1.0/appelepap>'
},
'valuePropertyPass1A': {
'valueType': 'edoal:Property',
'value': '<http://ts.tno.nl/mediator/1.0/appelepap>',
'lang': None
},
'valuePropertyPass1B': {
'valueType': 'edoal:Property',
'value': '<http://ts.tno.nl/mediator/1.0/appelepap>',
'lang': 'NL'
},
'valueRelationPass1': {
'valueType': 'edoal:Relation',
'value': '<http://ts.tno.nl/mediator/1.0/appelepap>'
}
},
'resources/valueSimplePass2.xml': {
'valueLiteralePass2A': {
'valueType': 'edoal:Apply',
'value': 'transformations.unitconversion/CtoF',
'type': '<http://ns.inria.org/edoal/1.0/#apply>'
},
'valueLiteralePass2B': {
'valueType': 'edoal:Apply',
'value': 'transformations.unitconversion/TempConvertor',
'type': '<http://ns.inria.org/edoal/1.0/#apply>'
}
},
'resources/valuePathPass1.xml': {
'valuePathPass1A': {
'valueType': 'edoal:compose',
'value': ['<http://ts.tno.nl/mediator/1.0/example#hasProperty> ({http://ns.inria.org/edoal/1.0/#}property)'],
'type': Alignment.EDOAL['PROP']
},
'valuePathPass1B': {
'valueType': 'edoal:compose',
'value': ['<http://ts.tno.nl/mediator/1.0/example#hasRelation> ({http://ns.inria.org/edoal/1.0/#}relation)', '<http://ts.tno.nl/mediator/1.0/example#hasProperty> ({http://ns.inria.org/edoal/1.0/#}property)'],
'type': Alignment.EDOAL['PROP']
},
'valuePathPass1C': {
'valueType': 'edoal:compose',
'value': ['<http://ts.tno.nl/mediator/1.0/example#hasRelation> ({http://ns.inria.org/edoal/1.0/#}relation)'],
'type': Alignment.EDOAL['RELN']
},
'valuePathPass1D': {
'valueType': 'edoal:compose',
'value': [],
'type': Alignment.EDOAL['PROP']
},
'valuePathPass1E': {
'valueType': 'edoal:compose',
'value': [],
'type': Alignment.EDOAL['RELN']
},
'valuePathPass1F': {
'valueType': 'edoal:compose',
'value': ['<http://ts.tno.nl/mediator/1.0/example#hasRelation1> ({http://ns.inria.org/edoal/1.0/#}relation)', '<http://ts.tno.nl/mediator/1.0/example#hasRelation2> ({http://ns.inria.org/edoal/1.0/#}relation)', '<http://ts.tno.nl/mediator/1.0/example#hasProperty> ({http://ns.inria.org/edoal/1.0/#}property)'],
'type': Alignment.EDOAL['PROP']
}
}
},
'fail': {
# The LiteralFail1 tests are all <Literal>'s, but not all possible literal values/xsd:valuetype's tested
'resources/valueSimpleFail1.xml': {
'FailEmpty1' : AssertionError, # Empty <entity> element
'FailLiteral1' : AssertionError, # Missing edoal:string attribute in <edoal:Literal\>
'FailLiteral2' : AssertionError, # Literal is always a single, empty element with its value in the attributes
'FailInstance1': AssertionError, # Missing rdf:about attribute in <edoal:Instance\>
'FailInstance2': AssertionError, # Empty rdf:about attribute in element
'FailInstance3': AssertionError, # Incorrect attribute in element
'FailInstance4': AssertionError, # Not an empty element
'FailProperty1': AssertionError, # Empty about attribute, empty Lang attribute
'FailProperty2': AssertionError, # Missing about attribute, empty Lang attribute
'FailProperty3': AssertionError, # Empty about attribute, missing Lang attribute
'FailProperty4': AssertionError, # Missing about attribute, missing Lang attribute
'FailProperty5': AssertionError, # Empty about attribute, valid Lang attribute
'FailProperty6': AssertionError, # Missing about attribute, valid Lang attribute
'FailRelation1': AssertionError, # Empty about attribute
'FailRelation2': AssertionError, # Missing about attribute
'FailRelation3': AssertionError # Valid attribute, invalid element (element is not empty)
},
'resources/valuePathFail1.xml': {
'FailPathOfNonAttrExpr1' : AssertionError, # Instance path is illegal
'FailPathOfNonAttrExpr2' : AssertionError, # Literal path is illegal
'FailPathOfNonAttrExpr3' : AssertionError, # Class path is illegal
'FailPathWithNonAttrExpr1': AssertionError, # Property Path containing Instance is illegal
'FailPathWithNonAttrExpr2': AssertionError, # Relation Path containing Literal is illegal
'FailPathWithNonAttrExpr3': AssertionError, # Relation Path containing Class is illegal
'FailComplexPathNotImpl' : NotImplementedError # Correct path, but too complex to be implemented yet
}
}
}
)
class TestEDOALParser(unittest.TestCase):
def setUp(self):
# from mediator.EDOALparser import Alignment
ns = {'rdf' : "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
'xsd' : "http://www.w3.org/2001/XMLSchema#",
'align':"http://knowledgeweb.semanticweb.org/heterogeneity/alignment#",
'dc' : 'http://purl.org/dc/elements/1.1/',
'edoal':'http://ns.inria.org/edoal/1.0/#',
'alext': 'http://exmo.inrialpes.fr/align/ext/1.0/',
'medtfn': 'http://ts.tno.nl/mediator/1.0/transformations#',
't' : 'http://ts.tno.nl/mediator/test#'
}
self.nsMgr = NSManager(ns, "http://knowledgeweb.semanticweb.org/heterogeneity/alignment#")
print(str(self.nsMgr))
self.testCases = {}
# Edoal parsing tests
'''
The admin tests will check the edoal Alignment element (refer to http://alignapi.gforge.inria.fr/format.html), however, restricted to:
* <xml>: (value: "yes"/"no") indicates if the alignment can be read as an XML file compliant with the DTD;
* <level>: (values: "0", "1", "2EDOAL") the level of alignment, characterising its type;
* <type>: (values: "11"/"1?"/"1+"/"1*"/"?1"/"??"/"?+"/"?*"/"+1"/"+?"/"++"/"+*"/"*1"/"*?"/"?+"/"**"; default "11")
This represents the arity of alignment. Usual notations are 1:1, 1:m, n:1 or n:m. We prefer to note if the mapping is injective,
surjective and total, or partial on both sides. We then end up with more alignment arities:
. 1 for injective and total,
. ? for injective,
. + for total and
. * for none
and each sign concerning one mapping and its converse;
* <onto1> and <onto2>: (value: Ontology) the source and target ontologies that are being aligned;
'''
self.testCases['ADMIN'] = []
self.testCases['ADMIN'].append(
{
'pass': {'resources/alignPassSimple0.xml': # Simple Class-EQ-Class, Prop-EQ-Prop, Reln-EQ-Reln
{'about': 'http://ds.tno.nl/ontoA-ontoB/CPR-EQ-CPR',
'admin': ['yes', 'PaulBrandt', '2015/08/25', 'manual', 'TEST DATA (simple alignments)', '2EDOAL', '?*'],
'ontoS': ["<http://tutorial.topbraid.com/ontoA#>", None, "<http://www.w3.org/2002/07/owl#>", "OWL1.0"],
'ontoT': ["<http://tutorial.topbraid.com/ontoB#>", "resources/nl/test1/ontoB.xml", "<http://www.w3.org/2002/07/owl#>", "OWL1.0"]
},
'resources/wine_align.xml': # Simple Class-EQ-Class, Prop-EQ-Prop, Reln-LT-Reln,
{'about': 'http://oms.omwg.org/wine-vin/', # & one SmplSrcCls-EQ-CmplxTgtCls, one CmpxlSrcCls-LT-CmplxTgtCls
'admin': ['yes', 'http://www.scharffe.fr/foaf.rdf', '2006/06/07', 'manual', 'TESTcase: hugely adapted from original wine-vin example', '2EDOAL', '**'],
'ontoS': ["<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#>", None, "<http://www.w3.org/TR/owl-guide/>", "owl"],
'ontoT': ["<http://ontology.deri.org/vin#>", "http://www.scharffe.fr/ontologies/OntologieDuVin.wsml", "<http://www.wsmo.org/wsml/wsml-syntax/wsml-dl>", "wsml"]
}
},
'fail':
[
['resources/alignFail0A.xml', RuntimeError], # Missing <Alignment> element
['resources/alignFail0B.xml', ValueError], # Missing 'alignET:about="somename"' in <Alignment > element
['resources/alignFail1A.xml', NotImplementedError], # Incorrect value for <Level> element: 2EDOAL expected
['resources/alignFail1B.xml', RuntimeError], # Missing <Level> element
['resources/alignFail2A.xml', RuntimeError], # Missing <type> element
['resources/alignFail2B.xml', ValueError], # Illegal value for <Level> element
['', AssertionError], # Missing file name
['resources/missingAlignFile.xml', AssertionError], # Illegal file name
]
}
)
'''
The Correspondence tests will check the edoal set of correspondences (the <Cell> elements; refer to http://alignapi.gforge.inria.fr/edoal.html), however, restricted to:
* <Cell {rdf:about=" URI "} />
* <entity1> entity </entity1>
* <entity2> entity </entity2>
* <relation> STRING </relation>
* <measure> STRING </measure>
These are all required elements
'''
self.testCases['CORR'] = []
self.testCases['CORR'].append(
{
'pass': {
'resources/alignPassSimple0.xml': { # Simple Class-EQ-Class, Prop-EQ-Prop, Reln-EQ-Reln
'corrs': [
{
'name' : "MappingRule_0",
'ent1' : {'et': Alignment.EDOAL['CLASS'], 'eir' : "<http://tutorial.topbraid.com/ontoA#unEquivanox>"},
'ent2' : {'et': Alignment.EDOAL['CLASS'], 'eir' : "<http://tutorial.topbraid.com/ontoB#OneEq>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_1",
'ent1' : {'et': Alignment.EDOAL['PROP'], 'eir' : "<http://tutorial.topbraid.com/ontoA#unEquivanox>"},
'ent2' : {'et': Alignment.EDOAL['PROP'], 'eir' : "<http://tutorial.topbraid.com/ontoB#OneEq>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_2",
'ent1' : {'et': Alignment.EDOAL['RELN'], 'eir' : "<http://tutorial.topbraid.com/ontoA#unEquivanox>"},
'ent2' : {'et': Alignment.EDOAL['RELN'], 'eir' : "<http://tutorial.topbraid.com/ontoB#OneEq>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_3",
'ent1' : {'et': Alignment.EDOAL['INST'], 'eir' : "<http://tutorial.topbraid.com/ontoA#unEquivanox>"},
'ent2' : {'et': Alignment.EDOAL['INST'], 'eir' : "<http://tutorial.topbraid.com/ontoB#OneEq>"},
'msre' : 1.0,
'reln' : 'EQ'
}
]
},
'resources/wine_align.xml': { # Simple Class-EQ-Class, Prop-EQ-Prop, Reln-LT-Reln,
'corrs': [
{
'name' : "MappingRule_0",
'ent1' : {'et': Alignment.EDOAL['CLASS'], 'eir' : "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"},
'ent2' : {'et': Alignment.EDOAL['CLASS'], 'eir' : "<http://ontology.deri.org/vin#Millesime>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_1",
'ent1' : {'et': Alignment.EDOAL['PROP'], 'eir' : "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"},
'ent2' : {'et': Alignment.EDOAL['PROP'], 'eir' : "<http://ontology.deri.org/vin#Millesime>"},
'msre' : 1.0,
'reln' : 'EQ'
}, {
'name' : "MappingRule_2",
'ent1' : {'et': Alignment.EDOAL['RELN'], 'eir' : "<http://www.w3.org/TR/2003/CR-owl-guide-20030818/wine#VintageYear>"},
'ent2' : {'et': Alignment.EDOAL['RELN'], 'eir' : "<http://ontology.deri.org/vin#Millesime>"},
'msre' : 1.0,
'reln' : 'EQ'
}
]
}
},
'fail': { # TODO: zet geen testdata in de edoal data, maar maak aparte 'fail'labels: 'AssertionErrors'
'resources/alignFail3A.xml': {
"MissingMap": RuntimeError}, # Missing <map><Cell>...</Cell></map> element
'resources/alignFail3B.xml': {
"MissingCell": RuntimeError}, # Missing <Cell> element
'resources/alignFail3C.xml': {
"MappingRule_0": AssertionError, # Empty <Cell> element
"MappingRule_1": AssertionError, # Missing <entity1> element
"MappingRule_11": AssertionError, # Multiple <entity1> element
"MappingRule_12": AssertionError, # Non-empty simple <class> element
"MappingRule_13": AssertionError, # Non-empty simple <property> element
"MappingRule_14": AssertionError, # Non-empty simple <relation> element
"MappingRule_15": AssertionError, # Non-empty simple <class> element
"MappingRule_16": AssertionError, # Non-empty simple <property> element
"MappingRule_17": AssertionError, # Non-empty simple <relation> element
"MappingRule_2": AssertionError, # Missing <entity2> element
"MappingRule_21": AssertionError, # Multiple <entity2> element
"MappingRule_3": RuntimeError, # Missing <relation> element
"MappingRule_31": RuntimeError, # Multiple <relation> element
"MappingRule_32": RuntimeError, # Illegal <relation> element
"MappingRule_4": RuntimeError, # Missing <measure> element
"MappingRule_41": RuntimeError, # Multiple <measure> element
"MappingRule_42": RuntimeError, # Missing About attribute in <measure> element
"MappingRule_5": AssertionError, # Missing About attribute in empty EDOAL element
"MappingRule_6": AssertionError, # Empty <entity> element
"MappingRule_7": AssertionError, # Unknown entity element in entity
"MappingRule_8": AssertionError # Unknown cell element in entity
}
}
}
)
'''
A Value expression is a rather central element in the EDAOL alginment. Therefore we designed a separate test for it.
BNF definition is (refer to http://alignapi.gforge.inria.fr/edoal.html):
<value> value </value>
value ::= <Literal {edoal:type=" URI "} edoal:string=" STRING " />
| instexpr
| attrexpr
| <Apply edoal:operator=" URI "> <arguments rdf:parseType="Collection">value*</arguments> </Apply>
| <Aggregate edoal:operator=" URI "> <arguments rdf:parseType="Collection">value*</arguments> </Aggregate>
instexpr ::= <Instance rdf:about=" URI "/>
attexpr ::= propexpr | relexpr
'''
self.testCases['VALUE'] = []
self.testCases['VALUE'].append(
{
'pass': {
# The LiteralPass1 tests are all <Literal>'s, but not all possible literal values/xsd:valuetype's have been specified and hence, tested
'resources/valueSimplePass1.xml': {
'valueLiteralePass1A': {
'valueType': 'edoal:Literal',
'value': 'appelepap',
'type': '<http://www.w3.org/2001/XMLSchema#string>'
},
'valueLiteralePass1B': {
'valueType': 'edoal:Literal',
'value': '123',
'type': '<http://www.w3.org/2001/XMLSchema#integer>'
},
'valueLiteralePass1C': {
'valueType': 'edoal:Literal',
'value': '1.23',
'type': '<http://www.w3.org/2001/XMLSchema#float>'
},
'valueInstancePass1': {
'valueType': 'edoal:Instance',
'value': '<http://ts.tno.nl/mediator/1.0/appelepap>'
},
'valuePropertyPass1A': {
'valueType': 'edoal:Property',
'value': '<http://ts.tno.nl/mediator/1.0/appelepap>',
'lang': None
},
'valuePropertyPass1B': {
'valueType': 'edoal:Property',
'value': '<http://ts.tno.nl/mediator/1.0/appelepap>',
'lang': 'NL'
},
'valueRelationPass1': {
'valueType': 'edoal:Relation',
'value': '<http://ts.tno.nl/mediator/1.0/appelepap>'
}
},
'resources/valueSimplePass2.xml': {
'valueLiteralePass2A': {
'valueType': 'edoal:Apply',
'value': 'transformations.unitconversion/CtoF',
'type': '<http://ns.inria.org/edoal/1.0/#apply>'
},
'valueLiteralePass2B': {
'valueType': 'edoal:Apply',
'value': 'transformations.unitconversion/TempConvertor',
'type': '<http://ns.inria.org/edoal/1.0/#apply>'
}
},
'resources/valuePathPass1.xml': {
'valuePathPass1A': {
'valueType': 'edoal:compose',
'value': ['<http://ts.tno.nl/mediator/1.0/example#hasProperty> ({http://ns.inria.org/edoal/1.0/#}property)'],
'type': Alignment.EDOAL['PROP']
},
'valuePathPass1B': {
'valueType': 'edoal:compose',
'value': ['<http://ts.tno.nl/mediator/1.0/example#hasRelation> ({http://ns.inria.org/edoal/1.0/#}relation)', '<http://ts.tno.nl/mediator/1.0/example#hasProperty> ({http://ns.inria.org/edoal/1.0/#}property)'],
'type': Alignment.EDOAL['PROP']
},
'valuePathPass1C': {
'valueType': 'edoal:compose',
'value': ['<http://ts.tno.nl/mediator/1.0/example#hasRelation> ({http://ns.inria.org/edoal/1.0/#}relation)'],
'type': Alignment.EDOAL['RELN']
},
'valuePathPass1D': {
'valueType': 'edoal:compose',
'value': [],
'type': Alignment.EDOAL['PROP']
},
'valuePathPass1E': {
'valueType': 'edoal:compose',
'value': [],
'type': Alignment.EDOAL['RELN']
},
'valuePathPass1F': {
'valueType': 'edoal:compose',
'value': ['<http://ts.tno.nl/mediator/1.0/example#hasRelation1> ({http://ns.inria.org/edoal/1.0/#}relation)', '<http://ts.tno.nl/mediator/1.0/example#hasRelation2> ({http://ns.inria.org/edoal/1.0/#}relation)', '<http://ts.tno.nl/mediator/1.0/example#hasProperty> ({http://ns.inria.org/edoal/1.0/#}property)'],
'type': Alignment.EDOAL['PROP']
}
}
},
'fail': {
# The LiteralFail1 tests are all <Literal>'s, but not all possible literal values/xsd:valuetype's tested
'resources/valueSimpleFail1.xml': {
'FailEmpty1' : AssertionError, # Empty <entity> element
'FailLiteral1' : AssertionError, # Missing edoal:string attribute in <edoal:Literal\>
'FailLiteral2' : AssertionError, # Literal is always a single, empty element with its value in the attributes
'FailInstance1': AssertionError, # Missing rdf:about attribute in <edoal:Instance\>
'FailInstance2': AssertionError, # Empty rdf:about attribute in element
'FailInstance3': AssertionError, # Incorrect attribute in element
'FailInstance4': AssertionError, # Not an empty element
'FailProperty1': AssertionError, # Empty about attribute, empty Lang attribute
'FailProperty2': AssertionError, # Missing about attribute, empty Lang attribute
'FailProperty3': AssertionError, # Empty about attribute, missing Lang attribute
'FailProperty4': AssertionError, # Missing about attribute, missing Lang attribute
'FailProperty5': AssertionError, # Empty about attribute, valid Lang attribute
'FailProperty6': AssertionError, # Missing about attribute, valid Lang attribute
'FailRelation1': AssertionError, # Empty about attribute
'FailRelation2': AssertionError, # Missing about attribute
'FailRelation3': AssertionError # Valid attribute, invalid element (element is not empty)
},
'resources/valuePathFail1.xml': {
'FailPathOfNonAttrExpr1' : AssertionError, # Instance path is illegal
'FailPathOfNonAttrExpr2' : AssertionError, # Literal path is illegal
'FailPathOfNonAttrExpr3' : AssertionError, # Class path is illegal
'FailPathWithNonAttrExpr1': AssertionError, # Property Path containing Instance is illegal
'FailPathWithNonAttrExpr2': AssertionError, # Relation Path containing Literal is illegal
'FailPathWithNonAttrExpr3': AssertionError, # Relation Path containing Class is illegal
'FailComplexPathNotImpl' : NotImplementedError # Correct path, but too complex to be implemented yet
}
}
}
)
def tearDown(self):
pass
def testParseEdoalAdmin(self):
'''parsing admin block of edoal should instantiate Alignment Object with valid admin getters,
and raise exception on faulty or missing XML elements'''
# from mediator.EDOALparser import Alignment
info = True
debug = 3
rule = 'ADMIN'
if info or debug >= 1:
print()
print('=-' * 7)
print('EDOAL parser tests, {} part'.format(rule))
print('=-' * 7)
for t in self.testCases[rule]:
if info:
print('\ntesting', rule, 'with', len(t['pass']), 'pass case(s) and', len(t['fail']), 'fail case(s)')
if debug >= 3:
print('> pass cases:', t['pass'])
print('> fail cases:', t['fail'])
print()
# PASS: Execute the test for each defined correspondence file that is expected to pass
for p, crit in t['pass'].items():
# Read and parse XML Alignment file
if debug >= 1:
print('testing pass case:', p)
if debug >= 3:
for k, v in crit.items():
print('\t{}: {}'.format(k, v))
pa = Alignment(fn=p, nsMgr=self.nsMgr)
# Validate the Administration part, i.e., the first elements in the Alignment.
assert pa.getAbout() == crit['about'], 'Alignment attribute "{}" conflicts with expected value {}'.format(pa.about, crit['about'])
assert pa.getCreator() == crit['admin'][1], 'Alignment attribute "{}" conflicts with expected value {}'.format(pa.getCreator(), crit['admin'][1])
assert pa.getDate() == crit['admin'][2], 'Alignment attribute "{}" conflicts with expected value {}'.format(pa.getDate(), crit['admin'][2])
assert pa.getMethod() == crit['admin'][3], 'Alignment attribute "{}" conflicts with expected value {}'.format(pa.getMethod(), crit['admin'][3])
assert pa.getPurpose() == crit['admin'][4], 'Alignment attribute "{}" conflicts with expected value {}'.format(pa.getPurpose(), crit['admin'][4])
assert pa.getLevel() == crit['admin'][5], 'Alignment attribute "{}" conflicts with expected value {}'.format(pa.getLevel(), crit['admin'][5])
assert pa.getType() == crit['admin'][6], 'Alignment attribute "{}" conflicts with expected value {}'.format(pa.getType(), crit['admin'][6])
# Validate the ontology references that are mentioned in the Alignment
onto = pa.getSrcOnto()
assert onto.name == crit['ontoS'][0], 'Alignment attribute "{}" conflicts with expected value {}'.format(onto.name, crit['ontoS'][0])
assert onto.location == crit['ontoS'][1], 'Alignment attribute "{}" conflicts with expected value {}'.format(onto.location, crit['ontoS'][1])
assert onto.formalism_uri == crit['ontoS'][2], 'Alignment attribute "{}" conflicts with expected value {}'.format(onto.formalism_uri, crit['ontoS'][2])
assert onto.formalism_name == crit['ontoS'][3], 'Alignment attribute "{}" conflicts with expected value {}'.format(onto.formalism_name, crit['ontoS'][3])
onto = pa.getTgtOnto()
assert onto.name == crit['ontoT'][0], 'Alignment attribute "{}" conflicts with expected value {}'.format(onto.name, crit['ontoT'][0])
assert onto.location == crit['ontoT'][1], 'Alignment attribute "{}" conflicts with expected value {}'.format(onto.location, crit['ontoT'][1])
assert onto.formalism_uri == crit['ontoT'][2], 'Alignment attribute "{}" conflicts with expected value {}'.format(onto.formalism_uri, crit['ontoT'][2])
assert onto.formalism_name == crit['ontoT'][3], 'Alignment attribute "{}" conflicts with expected value {}'.format(onto.formalism_name, crit['ontoT'][3])
# FAIL: Execute the test for each correspondence that is expected to fail on this query
f = []
for f in t['fail']:
# Read and parse XML Alignment file
if info or debug >= 1:
print('testing fail case:', f)
# Test that an incorrect EDOAL Alignment raises the correct exceptions
try:
# For every fail case, one of the below calls will result in an error
pa = Alignment(f[0], nsMgr=self.nsMgr)
_ = pa.getAbout()
_ = pa.getCreator()
_ = pa.getDate()
_ = pa.getMethod()
_ = pa.getPurpose()
_ = pa.getLevel()
_ = pa.getType()
_ = pa.getSrcOnto()
_ = pa.getTgtOnto()
raise TestException('TestNSManager {} should have raised exception {}'.format(f[0], f[1]))
except Exception as e: assert type(e) == f[1], 'TestNSManager {} should have raised exception {}; got {}'.format(f[0], f[1], type(e))
# Test the need for a proper nsMgr
properfile = list(t['pass'].keys())[0]
self.assertRaises(AssertionError, Alignment, properfile, None)
# with self.assertRaises(AssertionError):
# _ = Alignment(properfile, nsMgr=None)
# Test adding the same alignment twice
pa = Alignment(properfile, nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
pa._addAlignment(fn=properfile, nsMgr=self.nsMgr)
if info:
print('=' * 20)
def testParseEdoalCorrespondence(self):
# from mediator.EDOALparser import Alignment
info = True
debug = 3
rule = 'CORR'
if info or debug >= 1:
print()
print('=-' * 7)
print('EDOAL parser tests, {} part'.format(rule))
print('=-' * 7)
for t in self.testCases[rule]:
if info:
print('\ntesting', rule, 'with', len(t['pass']), 'pass case(s) and', len(t['fail']), 'fail case(s)')
if debug >= 3:
print('> pass cases:', t['pass'])
print('> fail cases:', t['fail'])
print()
# PASS: Execute the test for each defined correspondence file that is expected to pass
for p, crit in t['pass'].items():
# Read and parse XML Alignment file
if debug >= 1:
print('testing pass case:', p)
pa = Alignment(fn=p, nsMgr=self.nsMgr)
# Get each correspondence cell
cell_elements = pa._align.findall(pa.nsMgr.asClarks('align:map') + '/' + pa.nsMgr.asClarks('align:Cell'))
assert len(cell_elements) > 0, "Pass tests need to have at least one <align:map> element"
# Iterate over all <Cell>...</Cell> parts
for cell in cell_elements:
# Determine whether the CELL element is a pass or fail cell, based on its name
name = cell.get(pa.nsMgr.CLARKS_LABELS['RDFABOUT'])
for c in crit['corrs']:
if name == c['name']:
if debug >= 3: print('\t testing {} ..'.format(name), end="")
# Since this cell is part of a pass test, continue test
corr = pa._parseCorrespondence(cell)
assert corr.getName() == c['name']
entExpr = corr.getEE1()
assert entExpr.getIriRef() == c['ent1']['eir'], "Expected '{}', got '{}'".format(c['ent1']['eir'], entExpr.getIriRef())
assert entExpr.getType() == c['ent1']['et'], "Expected '{}', got '{}'".format(c['ent1']['et'], entExpr.getType())
if debug >= 3: print(". done")
break
if corr.getName() != c['name']:
# TODO: TestNSManager completeness - maak teller ipv afhankelijk te zijn van about name
raise TestException("Incomplete test setup, or invalid parsing: Testcase for {} expected but not found".format(corr.getName()))
# FAIL: Execute the test for each correspondence that is expected to fail on this query
f = []
for f in t['fail']:
if info or debug >= 1:
print('testing fail case:', f)
pa = Alignment(fn=f, nsMgr=self.nsMgr)
mappings = t['fail'][f]
assert pa != None and pa != [], "The fail tests, too, require an Edoal alignment. None found in testcase {}".format(f)
# Get each correspondence cell
map_elements = []
map_elements = pa._align.findall(pa.nsMgr.asClarks('align:map'))
if map_elements == []:
# Found absent <map> element, which should raise an exception
try:
if debug >= 3: print("\ttesting {} ..".format('MissingMap'), end="")
_ = pa.getCorrespondences()
raise TestException('Testcase {}: test {} should have raised exception {}'.format(f, 'MissingMap', mappings['MissingMap']))
except Exception as e:
assert type(e) == mappings['MissingMap'], 'TestNSManager should have raised exception {}; got {}'.format(mappings['MissingMap'], type(e))
if debug >= 3: print(". done")
else:
for map_element in map_elements:
cell_elements = map_element.findall(pa.nsMgr.asClarks('align:Cell'))
if cell_elements == []:
if debug >= 3: print("\ttesting {} ..".format('MissingCell'), end="")
# Found empty <map> element, which should raise an exception
try:
_ = pa.getCorrespondences()
raise TestException('Testcase {}: test {} should have raised exception {}'.format(f, 'MissingCell', mappings['MissingCell']))
except Exception as e:
assert type(e) == mappings['MissingCell'], 'TestNSManager should have raised exception {}; got {}'.format(mappings['MissingCell'], type(e))
if debug >= 3: print(". done")
else:
# iterate over all <Cell> elements and validate the failure of each cell
for cell in cell_elements:
name = cell.get(NSManager.CLARKS_LABELS['RDFABOUT'])
assert isinstance(name, str) and name != '', "An edoal {} element requires an {} attribute. None found in this cell in {}".format(cell.tag, pa.nsMrg.CLARKS_LABELS['RDFABOUT'], f)
if debug >= 3: print("\ttesting {} ..".format(name), end="")
try:
corr = pa._parseCorrespondence(cell)
raise TestException('Testcase {}: test {} should have raised exception {}'.format(f, name, mappings[name]))
except Exception as e:
assert type(e) == mappings[name], 'TestNSManager {} should have raised exception {}; got {}'.format(name, mappings[name], type(e))
if debug >= 3: print(". done")
w = 'resources/alignWarningPass1.xml'
print('testing warning case:', w)
pa = Alignment(fn=w, nsMgr=self.nsMgr)
assert pa != None and pa != [], "Test failure: The test requires an Edoal alignment. None found in testcase {}".format(w)
assert pa.getAbout() == "http://ds.tno.nl/ontoA-ontoB/DuplicateCells", "Test failure: other alignment read, got '{}'".format(pa.getAbout())
# Get each correspondence cell
cell_elements = pa._align.findall(pa.nsMgr.asClarks('align:map') + '/' + pa.nsMgr.asClarks('align:Cell'))
assert len(cell_elements) == 3, "Test failure: test needs to have 3 <align:map> elements, got {}".format(len(cell_elements))
print('\ttesting DuplicateCells ', end="")
# Iterate over all <Cell>...</Cell> parts
nameMgr = []
pa._corrs = []
for cell in cell_elements:
# There are three correct <Cell>'s, but the second is a duplicate.
# Assert that a duplicate warning is raised, and that the other two correspondences have been created.
print('.', end="")
name = cell.get(NSManager.CLARKS_LABELS['RDFABOUT'])
if name in nameMgr:
with self.assertWarns(UserWarning):
corr = pa._parseCorrespondence(cell)
else:
nameMgr.append(name)
corr = pa._parseCorrespondence(cell)
pa.appendCorrespondence(corr)
assert corr.getName() == name
assert len(pa.getCorrespondences()) == 2, "Got {}".format(len(pa.getCorrespondences()))
print(' done')
def testParseEdoalValue(self):
# from mediator.EDOALparser import Alignment
info = True
debug = 3
rule = 'VALUE'
if info or debug >= 1:
print()
print('=-' * 7)
print('EDOAL parser tests, {} part'.format(rule))
print('=-' * 7)
for t in self.testCases[rule]:
if info:
print('\ntesting', rule, 'with', len(t['pass']), 'pass case(s) and', len(t['fail']), 'fail case(s)')
if debug >= 3:
print('> pass cases:', t['pass'])
print('> fail cases:', t['fail'])
print()
testCriteria = []
# PASS: Execute the test for each defined correspondence file that is expected to pass
for testCase, testCriteria in t['pass'].items():
if debug >= 1:
print('PASS case {} has specified {} tests'.format(testCase, len(testCriteria)))
# Do the test
# Create a Alignment object only to have a valid Alignment object and create a valid nsMgr;
# the test data is incorrect edoal, and this code below takes that into consideration
pa = Alignment(fn=testCase, nsMgr=self.nsMgr)
testsEl = pa._align.findall(self.nsMgr.asClarks('t:tests'))
if testsEl == None or len(testsEl) == 0: raise TestException("No tests found, cannot perform tests")
tests = testsEl[0].findall(self.nsMgr.asClarks('t:test'))
if len(testCriteria) != len(tests): raise TestException('Test setup specifies {} tests, but {} tests found in test data ({})'.format(len(testCriteria), len(tests), testCase))
if debug >= 3: print('Found {} tests in test data'.format(len(tests)))
for test in tests:
tname = test.get(NSManager.CLARKS_LABELS['RDFABOUT'])
# Check the test data
if tname == None or tname == '': raise TestException('Testcase {}: Use of {} attribute in <test> element required to discern the various testCriteria'.format(testCase, NSManager.nsmap['RDFABOUT']))
edoal_entity = test.find(self.nsMgr.asClarks('edoal:entity1'))
if edoal_entity == None: raise TestException('Testcase {}: Test ({}) is required to contain an <entity1> element'.format(testCase, tname))
if debug >= 3: print('Testing test: {} ..'.format(tname), end="")
edoalValue = pa.Value(el=edoal_entity, parse_alignment=pa)
if edoalValue == None: raise TestException('Testcase {}: Test ({}) is required to contain a <value> element'.format(testCase, tname))
# Check the value type that is under test, perform the test and verify the outcome is as expected
if testCriteria[tname]['valueType'] == 'edoal:Literal':
assert (testCriteria[tname]['value'], testCriteria[tname]['type']) == edoalValue.getLiteral(), \
'Testcase {}, test {}: expected {} but found {}'.format(testCase, tname, (testCriteria[tname]['value'], testCriteria[tname]['type']), edoalValue.getLiteral())
elif testCriteria[tname]['valueType'] == 'edoal:Instance':
assert testCriteria[tname]['value'] == edoalValue.getIndividual(), 'Testcase {}, test {}: expected {} but found {}'.format(testCase, tname, testCriteria[tname]['value'], edoalValue.getIndividual())
elif testCriteria[tname]['valueType'] in ['edoal:Property', 'edoal:Relation']:
assert testCriteria[tname]['value'] == edoalValue.getAttrExpression(), 'Testcase {}, test {}: expected {} but found {}'.format(testCase, tname, testCriteria[tname]['value'], edoalValue.getAttrExpression())
elif testCriteria[tname]['valueType'] in ['edoal:Apply', 'edoal:Aggregate']:
assert testCriteria[tname]['value'] == edoalValue.getOperator().getName(), 'Testcase {}, test {}: expected {} but found {}'.format(testCase, tname, testCriteria[tname]['value'], edoalValue.getOperator().getName())
elif testCriteria[tname]['valueType'] == 'edoal:compose':
assert testCriteria[tname]['type'] == edoalValue.getEntityType(), 'Testcase {}, test {}: expected {} but found {}'.format(testCase, tname, testCriteria[tname]['type'], edoalValue.getEntityType())
if edoalValue.hasPath():
for criterion, attrExpr in zip(testCriteria[tname]['value'], edoalValue.getPath()):
assert criterion == str(attrExpr), 'Testcase {}, test {}: expected {} but found {}'.format(testCase, tname, criterion, attrExpr)
else: raise AssertionError('Testcase {}, test {}: missing path expression'.format(testCase, tname))
else: raise TestException('No test code implemented for value type {}, please specify and add test code'.format(testCriteria[tname]['valueType']))
if debug >= 3: print('. done')
# FAIL: Execute the testCriteria, which are expected to fail
for testCase, testCriteria in t['fail'].items():
if debug >= 1:
print('\nFAIL case {} has specified {} tests'.format(testCase, len(testCriteria)))
# Create a Alignment object only to have a valid Alignment object and create a valid nsMgr;
# the test data is incorrect edoal, and this code below takes that into consideration
pa = Alignment(fn=testCase, nsMgr=self.nsMgr)
testsEl = pa._align.findall(self.nsMgr.asClarks('t:tests'))
if testsEl == None or len(testsEl) == 0: raise TestException("No tests found, cannot perform tests")
tests = testsEl[0].findall(self.nsMgr.asClarks('t:test'))
if len(testCriteria) != len(tests): raise TestException('TestNSManager setup specifies {} tests, but {} tests found in test data ({})'.format(len(testCriteria), len(tests), testCase))
if debug >= 3: print('Found {} tests in test data'.format(len(tests)))
# Illegal use of the Alignment element
for test in tests:
tname = test.get(NSManager.CLARKS_LABELS['RDFABOUT'])
# Check the test data
if tname == None or tname == '': raise TestException('Testcase {}: Use of {} attribute in <test> element required to discern the various testCriteria'.format(testCase, NSManager.nsmap['RDFABOUT']))
edoal_entity = test.find(self.nsMgr.asClarks('edoal:entity1'))
if edoal_entity == None: raise TestException('Testcase {}: TestCase ({}) is required to contain an <entity1> element'.format(testCase, tname))
# Perform the test, check for the occurrence of an exception and verify that the fault condition raises the correct exception
try:
if debug >= 3: print('testing {} ...'.format(tname), end="")
_ = pa.Value(el=edoal_entity, parse_alignment=pa)
# This should be dead code, because an exception should have been raised
raise TestException('Testcase {}: Test {} failed, expected exception ({}) did not occur!'.format(testCase, tname, testCriteria[tname]))
except Exception as e: assert type(e) == testCriteria[tname], 'Testcase {}, test {}: expected {}, got {}'.format(testCase, tname, testCriteria[tname], type(e))
if debug >= 3: print('. done')
def test_parseOperation(self):
assert False, "Make test for method '_parseOperation()'"
def test_parseTransform(self):
assert False, "Make test for method '_parseTransform()'"
def testAlignment(self):
# Pass testcases
a = Alignment(fn='resources/valueSimplePass1.xml', nsMgr=self.nsMgr)
assert a.about == "http://ds.tno.nl/ontoA-ontoB/CPR-EQ-CPR"
# Fail testcases
with self.assertRaises(AssertionError):
_ = Alignment(fn='', nsMgr=self.nsMgr)
with self.assertRaises(AssertionError):
_ = Alignment(fn='resources/valueSimplePass1.xml', nsMgr=None)
class TestNSManager(unittest.TestCase):
def setUp(self):
testNS = {
'med': 'http://ds.tno.nl/mediator/1.0/',
'dc': 'http://purl.org/dc/elements/1.1/',
'edoal': 'http://ns.inria.org/edoal/1.0/#',
'test': 'http://ds.tno.nl/mediator/1.0'
}
self.base = 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#'
self.nsMgr = NSManager(nsDict=testNS, base=self.base)
def tearDown(self):
pass
def testNsConcat(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
assert self.nsMgr.nsConcat(
'http://www.w3.org/2001/XMLSchema#', 'appel'
) == '<http://www.w3.org/2001/XMLSchema#appel>', "got {}".format(
self.nsMgr.nsConcat('http://www.w3.org/2001/XMLSchema#', 'appel'))
assert self.nsMgr.nsConcat(
'<http://www.w3.org/2001/XMLSchema#>', 'appel'
) == '<http://www.w3.org/2001/XMLSchema#appel>', "got {}".format(
self.nsMgr.nsConcat('<http://www.w3.org/2001/XMLSchema#>',
'appel'))
assert self.nsMgr.nsConcat(
'http://www.w3.org/2001/XMLSchema/', 'appel'
) == '<http://www.w3.org/2001/XMLSchema/appel>', "got {}".format(
self.nsMgr.nsConcat('http://www.w3.org/2001/XMLSchema/', 'appel'))
assert self.nsMgr.nsConcat(
'<http://www.w3.org/2001/XMLSchema/>', 'appel'
) == '<http://www.w3.org/2001/XMLSchema/appel>', "got {}".format(
self.nsMgr.nsConcat('<http://www.w3.org/2001/XMLSchema/>',
'appel'))
assert self.nsMgr.nsConcat(
'http://www.w3.org/2001/XMLSchema', 'appel'
) == '<http://www.w3.org/2001/XMLSchema/appel>', "got {}".format(
self.nsMgr.nsConcat('http://www.w3.org/2001/XMLSchema', 'appel'))
assert self.nsMgr.nsConcat(
'<http://www.w3.org/2001/XMLSchema>', 'appel'
) == '<http://www.w3.org/2001/XMLSchema/appel>', "got {}".format(
self.nsMgr.nsConcat('<http://www.w3.org/2001/XMLSchema>', 'appel'))
print(". done")
def testCONSTANTS(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
assert self.nsMgr.CLARKS_LABELS[
'XSDSTRING'] == '{http://www.w3.org/2001/XMLSchema#}string'
assert self.nsMgr.CLARKS_LABELS[
'RDFABOUT'] == '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}about'
assert self.nsMgr.CLARKS_LABELS[
'RDFDATATP'] == '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}datatype'
assert self.nsMgr.CLARKS_LABELS[
'RDFPARSTP'] == '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}parseType'
assert self.nsMgr.CLARKS_LABELS[
'RDFDATATP'] == '{http://www.w3.org/1999/02/22-rdf-syntax-ns#}datatype'
assert self.nsMgr.CLARKS_LABELS[
'ALIGNMENT'] == '{http://knowledgeweb.semanticweb.org/heterogeneity/alignment#}Alignment'
print(". done")
def testSplitIRI(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
assert ('align', "Alignment") == self.nsMgr._splitIRI(
"<http://knowledgeweb.semanticweb.org/heterogeneity/alignment#Alignment>"
), "Unexpectedly got '{}'".format(
self.nsMgr._splitIRI(
"<http://knowledgeweb.semanticweb.org/heterogeneity/alignment#Alignment>"
))
assert ('med', "Alignment") == self.nsMgr._splitIRI(
"<http://ds.tno.nl/mediator/1.0/Alignment>")
with self.assertRaises(AssertionError):
self.nsMgr._splitIRI("http:Alignment")
with self.assertRaises(AssertionError):
self.nsMgr._splitIRI("<http:Alignment>")
with self.assertRaises(AssertionError):
self.nsMgr._splitIRI("Alignment")
with self.assertRaises(AssertionError):
self.nsMgr._splitIRI("<Alignment>")
with self.assertRaises(AssertionError):
self.nsMgr._splitIRI("{http://purl.org/dc/elements/1.1/}creator")
print(". done")
def testAsClarks(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
assert isinstance(self.nsMgr.asClarks('dc:creator'), str)
assert self.nsMgr.asClarks(
'dc:creator'
) == '{http://purl.org/dc/elements/1.1/}creator', 'Expected "{http://purl.org/dc/elements/1.1/}creator", got {}'.format(
self.nsMgr.asClarks('dc:creator'))
assert self.nsMgr.asClarks(
"<http://purl.org/dc/elements/1.1/creator>"
) == '{http://purl.org/dc/elements/1.1/}creator', 'Expected "{http://purl.org/dc/elements/1.1/}creator", got {}'.format(
self.nsMgr.asClarks("<http://purl.org/dc/elements/1.1/creator>"))
assert self.nsMgr.asClarks(
':align'
) == '{' + self.base + '}align', 'Expected: {}, got: {}'.format(
'{' + self.base + '}align', str(self.nsMgr.asClarks(':align')))
with self.assertRaises(Exception):
self.nsMgr.asClarks('none:creator')
with self.assertRaises(Exception):
self.nsMgr.asClarks('dc:creator:invalidQname')
print(". done")
def testAsIri(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
print(str(self.nsMgr))
# Success scenarios
inpstr = 'dc:creator'
expstr = '<http://purl.org/dc/elements/1.1/creator>'
assert str(self.nsMgr.asIRI(
inpstr)) == expstr, 'Expected: {}, got: {}'.format(
expstr, str(self.nsMgr.asIRI(inpstr)))
inpstr = 'test:creator'
expstr = '<http://ds.tno.nl/mediator/1.0/creator>'
assert str(self.nsMgr.asIRI(
inpstr)) == expstr, 'Expected: {}, got: {}'.format(
expstr, str(self.nsMgr.asIRI(inpstr)))
inpstr = ':align'
expstr = '<' + self.base + 'align>'
assert str(self.nsMgr.asIRI(
inpstr)) == expstr, 'Expected: {}, got: {}'.format(
expstr, str(self.nsMgr.asIRI(inpstr)))
inpstr = '{}align'
expstr = '<' + self.base + 'align>'
assert str(self.nsMgr.asIRI(
inpstr)) == expstr, 'Expected: {}, got: {}'.format(
expstr, str(self.nsMgr.asIRI(inpstr)))
inpstr = '<http://purl.org/dc/elements/1.1/creator>'
expstr = '<http://purl.org/dc/elements/1.1/creator>'
assert str(self.nsMgr.asIRI(
inpstr)) == expstr, 'Expected: {}, got: {}'.format(
expstr, str(self.nsMgr.asIRI(inpstr)))
inpstr = '{http://purl.org/dc/elements/1.1/}creator'
expstr = '<http://purl.org/dc/elements/1.1/creator>'
assert str(self.nsMgr.asIRI(
inpstr)) == expstr, 'Expected: {}, got: {}'.format(
expstr, str(self.nsMgr.asIRI(inpstr)))
# Fail scenarios
with self.assertRaises(Exception):
self.nsMgr.asIri('')
with self.assertRaises(Exception):
self.nsMgr.asIri('<>')
with self.assertRaises(Exception):
self.nsMgr.asIri(':')
with self.assertRaises(Exception):
self.nsMgr.asIri('<:>')
with self.assertRaises(Exception):
self.nsMgr.asIri('{}')
with self.assertRaises(Exception):
self.nsMgr.asIri('<{}>')
with self.assertRaises(Exception):
self.nsMgr.asIri('{<>}')
with self.assertRaises(Exception):
self.nsMgr.asIri('{}creator{}')
with self.assertRaises(Exception):
self.nsMgr.asIri('{}{}creator')
with self.assertRaises(Exception):
self.nsMgr.asIri('<none:creator>')
with self.assertRaises(Exception):
self.nsMgr.asIri('<dc:creator:invalidQname>')
print(". done")
def testPrefix(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
pf = self.nsMgr.getPrefix('http://ds.tno.nl/mediator/1.0/')
assert pf == 'med', "Expected {}, got {}".format('med', pf)
# TestNSManager creation of new prefix
pf = self.nsMgr.getPrefix('http://ds.tno.nl/non-existent/1.0/')
cntr = self.nsMgr._prefixCntr
expectedPF = self.nsMgr.newPrefix()[:-1] + str(cntr)
assert pf == expectedPF, "Expected {}, got {}".format(expectedPF, pf)
# TestNSManager new prefix has been registered, i.e., no new prefix has been created again
pf = self.nsMgr.getPrefix('http://ds.tno.nl/non-existent/1.0/')
assert pf == expectedPF, "Expected {}, got {}".format(expectedPF, pf)
print(". done")
def testIsQName(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
assert self.nsMgr.isQName('appel:ei')
assert self.nsMgr.isQName(':ei')
assert not self.nsMgr.isQName('')
assert not self.nsMgr.isQName(':')
assert not self.nsMgr.isQName('appel:')
assert not self.nsMgr.isQName(':appel:ei')
assert not self.nsMgr.isQName('koe:appel:ei')
assert not self.nsMgr.isQName(
'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#egg')
print(". done")
def testIsClarks(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
assert self.nsMgr.isClarks('{appel}ei')
assert self.nsMgr.isClarks('{}ei')
assert not self.nsMgr.isClarks('')
assert not self.nsMgr.isClarks('{}')
assert not self.nsMgr.isClarks('{appel}')
assert not self.nsMgr.isClarks('appel{}')
assert not self.nsMgr.isClarks('appel{ei}')
assert not self.nsMgr.isClarks('{}{appel}ei')
assert not self.nsMgr.isClarks('{koe}{appel}ei')
assert not self.nsMgr.isClarks('}appel}ei')
assert not self.nsMgr.isClarks('{appel{ei')
assert not self.nsMgr.isClarks('{appel}{ei')
assert not self.nsMgr.isClarks('{appel{}ei')
print(". done")
def testIsIRI(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
assert self.nsMgr.isIRI(
'<preamb://authority.name/iri_expans/iri_path>')
assert self.nsMgr.isIRI(
'<preamb://authority.org/iri_expans/iri_expans/iri_path>')
assert self.nsMgr.isIRI('<preamb://authority.org/iri_expans#iri_path>')
assert self.nsMgr.isIRI(
'<preamb://authority.org/iri_expans/iri_expans#iri_path>')
assert self.nsMgr.isIRI(
'<http://knowledgeweb.semanticweb.org/heterogeneity/alignment#Alignment>'
)
assert self.nsMgr.isIRI('<http://ds.tno.nl/mediator/1.0/Alignment>')
assert self.nsMgr.isIRI(
'<preamb://authority.org/iri_expans/iri_expans#subpath/path>')
assert not self.nsMgr.isIRI(
'preamb://authority.fives/iri_expans/iri_path')
assert not self.nsMgr.isIRI(
'preamb://authority.name/iri_expans/iri_path>')
assert not self.nsMgr.isIRI(
'<preamb://authority.name/iri_expans/iri_path')
assert not self.nsMgr.isIRI(
'<preamb://authority.l/iri_expans/iri_path>')
assert not self.nsMgr.isIRI(
'<preamb://authority./iri_expans/iri_path>')
assert not self.nsMgr.isIRI('<preamb://authority/iri_expans/iri_path>')
assert not self.nsMgr.isIRI(
'<://authority.something/iri_expans/iri_path>')
assert not self.nsMgr.isIRI(
'<preamb:authority.something/iri_expans/iri_path>')
assert not self.nsMgr.isIRI('<preamb:authority>')
assert not self.nsMgr.isIRI(
'<{preamb://authority.org/iri_expans/iri_expans#}iri_path>')
assert not self.nsMgr.isIRI(
'<{preamb://authority.org/iri_expans/iri_expans/}iri_path>')
assert not self.nsMgr.isIRI(
'<preamb://authority.org/iri_expans/iri_expan/iri_path#>')
assert not self.nsMgr.isIRI(
'<preamb://authority.org/iri_expans/iri_expans#iri_path/>')
assert not self.nsMgr.isIRI(
'<preamb://authority.org/iri_expans/iri_expans/iri_path/>')
print(". done")
def testSplit(self):
print('Testcase {}\n\ttesting {} ..'.format(
self.__class__.__name__,
inspect.currentframe().f_code.co_name),
end="",
flush=True)
# Success scenarios
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('dc:path')
assert pf == 'dc' and prefix_expansion == 'http://purl.org/dc/elements/1.1/' and iri_path == 'path', "Got pf:{}, expansion:{}, path:{}".format(
pf, prefix_expansion, iri_path)
pf, prefix_expansion, iri_path = self.nsMgr.splitIri(':path')
assert pf == '' and prefix_expansion == 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#' and iri_path == 'path', "Got pf:{}, expansion:{}, path:{}".format(
pf, prefix_expansion, iri_path)
pf, prefix_expansion, iri_path = self.nsMgr.splitIri(
'{http://purl.org/dc/elements/1.1/}path')
assert pf == 'dc' and prefix_expansion == 'http://purl.org/dc/elements/1.1/' and iri_path == 'path', "Got pf:{}, expansion:{}, path:{}".format(
pf, prefix_expansion, iri_path)
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('{}path')
assert pf == '' and prefix_expansion == 'http://knowledgeweb.semanticweb.org/heterogeneity/alignment#' and iri_path == 'path', "Got pf:{}, expansion:{}, path:{}".format(
pf, prefix_expansion, iri_path)
# Fail scenarios
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('path:')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a*a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a!a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a@a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a$a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a%a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a^a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a&a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a(a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a)a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a_a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a-a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a+a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a=a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a[a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a]a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a|a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a;a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a"a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri("a'a")
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a~a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a`a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a,a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a<a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a>a')
with self.assertRaises(NotImplementedError):
pf, prefix_expansion, iri_path = self.nsMgr.splitIri('a?a')
print(". done")