oldaplib 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

oldaplib/test/test_resourceclass.py

@@ -152,8 +152,8 @@ class TestResourceClass(unittest.TestCase):
     def test_constructor(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:testprop'),
-                           subPropertyOf=Iri('test:comment'),
+                           property_class_iri=Xsd_QName('test:testprop'),
+                           subPropertyOf=Xsd_QName('test:comment'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["Test property@en", "Testprädikat@de"]),
                            description=LangString("A property for testing...@en"),
@@ -162,21 +162,21 @@ class TestResourceClass(unittest.TestCase):
 
         p2 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:enumprop'),
+                           property_class_iri=Xsd_QName('test:enumprop'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["Test enum@en", "Enumerationen@de"]),
                            inSet=RdfSet(Xsd_string("yes"), Xsd_string("maybe"), Xsd_string("no")))
 
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), maxCount=1, order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:test"), minCount=1, order=2),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:test"), minCount=1, order=2),
             HasProperty(con=self._connection, project=self._project, prop=p1, maxCount=1, order=3),
             HasProperty(con=self._connection, project=self._project, prop=p2, minCount=1, maxCount=1, order=4)
         ]
 
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResource"),
+                           owlclass_iri=Xsd_QName("test:TestResource"),
                            label=LangString(["Test resource@en", "Resource de test@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -188,41 +188,41 @@ class TestResourceClass(unittest.TestCase):
         self.assertTrue(r1[ResClassAttribute.CLOSED])
         self.assertTrue(r1.closed)
 
-        prop1 = r1[Iri("test:comment")].prop
-        self.assertEqual(r1[Iri("test:comment")].maxCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri("test:comment")].order, Xsd_decimal(1))
+        prop1 = r1[Xsd_QName("test:comment")].prop
+        self.assertEqual(r1[Xsd_QName("test:comment")].maxCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName("test:comment")].order, Xsd_decimal(1))
         self.assertIsNotNone(prop1)
         self.assertIsNone(prop1.internal)
-        self.assertEqual(prop1.property_class_iri, Iri("test:comment"))
+        self.assertEqual(prop1.property_class_iri, Xsd_QName("test:comment"))
         self.assertEqual(prop1.datatype, XsdDatatypes.langString)
         self.assertEqual(prop1.name, LangString(["comment@en", "Kommentar@de"]))
         self.assertEqual(prop1.description, LangString("This is a test property@de"))
         self.assertEqual(prop1.uniqueLang, Xsd_boolean(True))
 
-        prop2 = r1[Iri("test:test")].prop
-        self.assertEqual(r1[Iri("test:test")].minCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri("test:test")].order, Xsd_decimal(2))
+        prop2 = r1[Xsd_QName("test:test")].prop
+        self.assertEqual(r1[Xsd_QName("test:test")].minCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName("test:test")].order, Xsd_decimal(2))
         self.assertIsNone(prop2.internal)
-        self.assertEqual(prop2.property_class_iri, Iri("test:test"))
+        self.assertEqual(prop2.property_class_iri, Xsd_QName("test:test"))
         self.assertEqual(prop2.datatype, XsdDatatypes.string)
         self.assertEqual(prop2.description, LangString("Property shape for testing purposes"))
 
-        prop3 = r1[Iri("test:testprop")].prop
-        self.assertEqual(r1[Iri("test:testprop")].maxCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri("test:testprop")].order, Xsd_decimal(3))
-        self.assertEqual(prop3.internal, Iri('test:TestResource'))
-        self.assertEqual(prop3.property_class_iri, Iri("test:testprop"))
+        prop3 = r1[Xsd_QName("test:testprop")].prop
+        self.assertEqual(r1[Xsd_QName("test:testprop")].maxCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName("test:testprop")].order, Xsd_decimal(3))
+        self.assertEqual(prop3.internal, Xsd_QName('test:TestResource'))
+        self.assertEqual(prop3.property_class_iri, Xsd_QName("test:testprop"))
         self.assertEqual(prop3.type, OwlPropertyType.OwlDataProperty)
         self.assertEqual(prop3.datatype, XsdDatatypes.langString)
         self.assertEqual(prop3.name, LangString(["Test property@en", "Testprädikat@de"]))
-        self.assertEqual(prop3.subPropertyOf, Iri("test:comment"))
+        self.assertEqual(prop3.subPropertyOf, Xsd_QName("test:comment"))
         self.assertEqual(prop3.uniqueLang,  Xsd_boolean(True))
         self.assertEqual(prop3.languageIn, LanguageIn(Language.EN, Language.DE, Language.FR, Language.IT))
 
-        prop4 = r1[Iri("test:enumprop")].prop
-        self.assertEqual(r1[Iri("test:enumprop")].maxCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri("test:enumprop")].minCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri("test:enumprop")].order, Xsd_decimal(4))
+        prop4 = r1[Xsd_QName("test:enumprop")].prop
+        self.assertEqual(r1[Xsd_QName("test:enumprop")].maxCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName("test:enumprop")].minCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName("test:enumprop")].order, Xsd_decimal(4))
         self.assertEqual(prop4[PropClassAttr.IN],
                          RdfSet(Xsd_string("yes"), Xsd_string("maybe"), Xsd_string("no")))
 
@@ -230,14 +230,14 @@ class TestResourceClass(unittest.TestCase):
     def test_gaga(self):
         ep = PropertyClass(con=self._connection,
                            project="test",
-                           property_class_iri=Iri("schema:givenName"),
+                           property_class_iri=Xsd_QName("schema:givenName"),
                            datatype=XsdDatatypes.string,
                            maxLength=64,
                            minLength=3,
                            _externalOntology=Xsd_boolean(True))
         ep2 = PropertyClass(con=self._connection,
                             project="test",
-                            property_class_iri=Iri("schema:comment"),
+                            property_class_iri=Xsd_QName("schema:comment"),
                             toClass='schema:Comment')
         hasproperties: list[HasProperty] = [
             HasProperty(con=self._connection, project=self._project, prop=ep2, minCount=1, order=1),
@@ -246,24 +246,24 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project="test",
-                           owlclass_iri=Iri("test:Gaga"),
+                           owlclass_iri=Xsd_QName("test:Gaga"),
                            label=LangString(["Test gaga@en", "Resource de gaga@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
                            hasproperties=hasproperties)
-        p2 = r1[Iri('schema:description')]
+        p2 = r1[Xsd_QName('schema:description')]
         #r1.write_as_trig("0000000.trig")
         r1.create()
-        p2 = r1[Iri('schema:description')]
+        p2 = r1[Xsd_QName('schema:description')]
 
         r2 = ResourceClass.read(con=self._connection,
                                 project="test",
-                                owl_class_iri=Iri('test:Gaga'),
+                                owl_class_iri=Xsd_QName('test:Gaga'),
                                 ignore_cache=True)
         #r2.write_as_trig("111111111.trig")
-        p1 = r2[Iri('schema:comment')]
-        self.assertIsInstance(p1.prop.property_class_iri, Iri)
-        p2 = r2[Iri('schema:description')]
+        p1 = r2[Xsd_QName('schema:comment')]
+        self.assertIsInstance(p1.prop.property_class_iri, Xsd_QName)
+        p2 = r2[Xsd_QName('schema:description')]
 
     def test_create_next_generation(self):
         #
@@ -271,12 +271,12 @@ class TestResourceClass(unittest.TestCase):
         #
         p0 = PropertyClass(con=self._connection,
                            project="test",
-                           property_class_iri=Iri('test:standalone'),
+                           property_class_iri=Xsd_QName('test:standalone'),
                            datatype=XsdDatatypes.integer)
         p0.create()
         p0 = PropertyClass.read(con=self._connection,
                                 project="test",
-                                property_class_iri=Iri('test:standalone'),
+                                property_class_iri=Xsd_QName('test:standalone'),
                                 ignore_cache=True)
 
         #
@@ -284,7 +284,7 @@ class TestResourceClass(unittest.TestCase):
         #
         p1 = PropertyClass(con=self._connection,
                            project="test",
-                           property_class_iri=Iri('test:internal'),
+                           property_class_iri=Xsd_QName('test:internal'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["internal@en", "internal@de"]),
                            description=LangString("A property for testing...@en"),
@@ -296,7 +296,7 @@ class TestResourceClass(unittest.TestCase):
         #
         p2 = PropertyClass(con=self._connection,
                            project="test",
-                           property_class_iri=Iri('test:internalWithSuper'),
+                           property_class_iri=Xsd_QName('test:internalWithSuper'),
                            subPropertyOf=Iri('dcterms:description'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["internalWithSuper@en", "internalWithSuper@de"]),
@@ -310,13 +310,13 @@ class TestResourceClass(unittest.TestCase):
         hasproperties: list[HasProperty] = [
             HasProperty(con=self._connection, project=self._project, prop=p1, maxCount=1, order=1),
             HasProperty(con=self._connection, project=self._project, prop=p2, minCount=1, maxCount=1, order=2),
-            HasProperty(con=self._connection, project=self._project, prop=Iri('schema:comment'), minCount=1, order=3),
-            HasProperty(con=self._connection, project=self._project, prop=Iri('schema:description')),
-            HasProperty(con=self._connection, project=self._project, prop=Iri('test:standalone'), maxCount=1, order=4)
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName('schema:comment'), minCount=1, order=3),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName('schema:description')),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName('test:standalone'), maxCount=1, order=4)
         ]
         r1 = ResourceClass(con=self._connection,
                            project="test",
-                           owlclass_iri=Iri("test:TestResourceNextGeneration"),
+                           owlclass_iri=Xsd_QName("test:TestResourceNextGeneration"),
                            label=LangString(["Test resource@en", "Resource de test@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -325,16 +325,16 @@ class TestResourceClass(unittest.TestCase):
 
         r1 = ResourceClass.read(con=self._connection,
                                 project="test",
-                                owl_class_iri=Iri('test:TestResourceNextGeneration'),
+                                owl_class_iri=Xsd_QName('test:TestResourceNextGeneration'),
                                 ignore_cache=True)
-        p1 = r1[Iri('test:internal')]
+        p1 = r1[Xsd_QName('test:internal')]
         self.assertEqual(p1.prop.datatype, XsdDatatypes.langString)
         self.assertEqual(p1.prop.name, LangString(["internal@en", "internal@de"]))
         self.assertEqual(p1.maxCount, 1)
         self.assertIsNone(p1.minCount)
         self.assertEqual(p1.order, 1)
 
-        p2 = r1[Iri('test:internalWithSuper')]
+        p2 = r1[Xsd_QName('test:internalWithSuper')]
         self.assertEqual(p2.maxCount, 1)
         self.assertEqual(p2.minCount, 1)
         self.assertEqual(p2.order, 2)
@@ -345,20 +345,20 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(p2.prop.uniqueLang,  Xsd_boolean(True))
         self.assertEqual(p2.prop.languageIn, LanguageIn(Language.EN, Language.DE, Language.FR, Language.IT))
 
-        p3 = r1[Iri('schema:comment')]
+        p3 = r1[Xsd_QName('schema:comment')]
         self.assertEqual(p3.minCount, 1)
         self.assertIsNone(p3.maxCount)
         self.assertEqual(p3.order, 3)
         self.assertIsNone(p3.group)
-        self.assertIsInstance(p3.prop.property_class_iri, Iri)
+        self.assertIsInstance(p3.prop.property_class_iri, Xsd_QName)
 
-        p4 = r1[Iri('schema:description')]
+        p4 = r1[Xsd_QName('schema:description')]
         self.assertIsNone(p4.minCount)
         self.assertIsNone(p4.maxCount)
         self.assertIsNone(p4.order)
-        self.assertIsInstance(p4.prop.property_class_iri, Iri)
+        self.assertIsInstance(p4.prop.property_class_iri, Xsd_QName)
 
-        p5 = r1[Iri('test:standalone')]
+        p5 = r1[Xsd_QName('test:standalone')]
         self.assertIsNone(p5.minCount)
         self.assertEqual(p5.maxCount, 1)
         self.assertEqual(p5.order, 4)
@@ -369,7 +369,7 @@ class TestResourceClass(unittest.TestCase):
     def test_constructor_projectns(self):
         p1 = PropertyClass(con=self._connection,
                            project="test",
-                           property_class_iri=Iri('test:testpropns'),
+                           property_class_iri=Xsd_QName('test:testpropns'),
                            subPropertyOf=Iri('test:comment'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["Test property@en", "Testprädikat@de"]),
@@ -379,7 +379,7 @@ class TestResourceClass(unittest.TestCase):
 
         p2 = PropertyClass(con=self._connection,
                            project="test",
-                           property_class_iri=Iri('test:enumpropns'),
+                           property_class_iri=Xsd_QName('test:enumpropns'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["Test enum@en", "Enumerationen@de"]),
                            inSet=RdfSet(Xsd_string("yes"), Xsd_string("maybe"), Xsd_string("no")))
@@ -391,7 +391,7 @@ class TestResourceClass(unittest.TestCase):
 
         r1 = ResourceClass(con=self._connection,
                            project="test",
-                           owlclass_iri=Iri("test:TestResource"),
+                           owlclass_iri=Xsd_QName("test:TestResource"),
                            label=LangString(["Test resource@en", "Resource de test@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -405,21 +405,21 @@ class TestResourceClass(unittest.TestCase):
 
     def test_resourceclass_serialize_deserialize_A(self):
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), maxCount=1, order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:test"), minCount=1, order=2),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:test"), minCount=1, order=2),
         ]
 
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResourceDeepcopyA"),
+                           owlclass_iri=Xsd_QName("test:TestResourceDeepcopyA"),
                            hasproperties=hasproperties)
         r1.create()
         jsonstr = json.dumps(r1, default=serializer.encoder_default)
         r2 = json.loads(jsonstr, object_hook=serializer.make_decoder_hook(connection=self._connection))
 
-        p_a = r1[Iri("test:comment")].prop
+        p_a = r1[Xsd_QName("test:comment")].prop
         self.assertIsNone(p_a.internal)
-        p_b = r2[Iri("test:comment")].prop
+        p_b = r2[Xsd_QName("test:comment")].prop
         self.assertIsNone(p_b.internal)
 
 
@@ -427,8 +427,8 @@ class TestResourceClass(unittest.TestCase):
     def test_resourceclass_serialize_deserialize(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:deepc_prop1'),
-                           subPropertyOf=Iri('test:comment'),
+                           property_class_iri=Xsd_QName('test:deepc_prop1'),
+                           subPropertyOf=Xsd_QName('test:comment'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["Test property@en", "Testprädikat@de"]),
                            description=LangString("A property for testing...@en"),
@@ -437,21 +437,21 @@ class TestResourceClass(unittest.TestCase):
 
         p2 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:deepc_prop2'),
+                           property_class_iri=Xsd_QName('test:deepc_prop2'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["Test enum@en", "Enumerationen@de"]),
                            inSet=RdfSet(Xsd_string("yes"), Xsd_string("maybe"), Xsd_string("no")))
 
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), maxCount=1, order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:test"), minCount=1, order=2),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:test"), minCount=1, order=2),
             HasProperty(con=self._connection, project=self._project, prop=p1, maxCount=1, order=3),
             HasProperty(con=self._connection, project=self._project, prop=p2, minCount=1, maxCount=1, order=4)
         ]
 
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResourceDeepcopy"),
+                           owlclass_iri=Xsd_QName("test:TestResourceDeepcopy"),
                            label=LangString(["Test resource@en", "Resource de test@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -471,11 +471,11 @@ class TestResourceClass(unittest.TestCase):
         self.assertTrue(r2[ResClassAttribute.CLOSED])
         self.assertTrue(r2.closed)
 
-        self.assertEqual(r1[Iri("test:comment")].maxCount, r2[Iri("test:comment")].maxCount)
-        self.assertEqual(r1[Iri("test:comment")].order, r2[Iri("test:comment")].order)
+        self.assertEqual(r1[Xsd_QName("test:comment")].maxCount, r2[Xsd_QName("test:comment")].maxCount)
+        self.assertEqual(r1[Xsd_QName("test:comment")].order, r2[Xsd_QName("test:comment")].order)
 
-        prop1a = r1[Iri("test:comment")].prop
-        prop1b = r2[Iri("test:comment")].prop
+        prop1a = r1[Xsd_QName("test:comment")].prop
+        prop1b = r2[Xsd_QName("test:comment")].prop
         self.assertIsNotNone(prop1b)
         self.assertIsNone(prop1b.internal)
         self.assertEqual(prop1a.property_class_iri, prop1b.property_class_iri)
@@ -484,19 +484,19 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop1a.description, prop1b.description)
         self.assertEqual(prop1a.uniqueLang, prop1b.uniqueLang)
 
-        self.assertEqual(r1[Iri("test:test")].minCount, r2[Iri("test:test")].minCount)
-        self.assertEqual(r1[Iri("test:test")].order, r2[Iri("test:test")].order)
-        prop2a = r1[Iri("test:test")].prop
-        prop2b = r2[Iri("test:test")].prop
+        self.assertEqual(r1[Xsd_QName("test:test")].minCount, r2[Xsd_QName("test:test")].minCount)
+        self.assertEqual(r1[Xsd_QName("test:test")].order, r2[Xsd_QName("test:test")].order)
+        prop2a = r1[Xsd_QName("test:test")].prop
+        prop2b = r2[Xsd_QName("test:test")].prop
         self.assertIsNone(prop2b.internal)
         self.assertEqual(prop2a.property_class_iri, prop2b.property_class_iri)
         self.assertEqual(prop2a.datatype, prop2b.datatype)
         self.assertEqual(prop2a.description, prop2b.description)
 
-        self.assertEqual(r1[Iri("test:deepc_prop1")].maxCount, r2[Iri("test:deepc_prop1")].maxCount)
-        self.assertEqual(r1[Iri("test:deepc_prop1")].order, r2[Iri("test:deepc_prop1")].order)
-        prop3a = r1[Iri("test:deepc_prop1")].prop
-        prop3b = r2[Iri("test:deepc_prop1")].prop
+        self.assertEqual(r1[Xsd_QName("test:deepc_prop1")].maxCount, r2[Xsd_QName("test:deepc_prop1")].maxCount)
+        self.assertEqual(r1[Xsd_QName("test:deepc_prop1")].order, r2[Xsd_QName("test:deepc_prop1")].order)
+        prop3a = r1[Xsd_QName("test:deepc_prop1")].prop
+        prop3b = r2[Xsd_QName("test:deepc_prop1")].prop
         self.assertEqual(prop3a.internal, prop3b.internal)
         self.assertEqual(prop3a.property_class_iri, prop3b.property_class_iri)
         self.assertEqual(prop3a.type, prop3b.type)
@@ -506,61 +506,61 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop3a.uniqueLang,  prop3b.uniqueLang)
         self.assertEqual(prop3a.languageIn, prop3b.languageIn)
 
-        self.assertEqual(r1[Iri("test:deepc_prop2")].maxCount, r2[Iri("test:deepc_prop2")].maxCount)
-        self.assertEqual(r1[Iri("test:deepc_prop2")].minCount, r2[Iri("test:deepc_prop2")].minCount)
-        self.assertEqual(r1[Iri("test:deepc_prop2")].order, r2[Iri("test:deepc_prop2")].order)
-        prop4a = r1[Iri("test:deepc_prop2")].prop
-        prop4b = r2[Iri("test:deepc_prop2")].prop
+        self.assertEqual(r1[Xsd_QName("test:deepc_prop2")].maxCount, r2[Xsd_QName("test:deepc_prop2")].maxCount)
+        self.assertEqual(r1[Xsd_QName("test:deepc_prop2")].minCount, r2[Xsd_QName("test:deepc_prop2")].minCount)
+        self.assertEqual(r1[Xsd_QName("test:deepc_prop2")].order, r2[Xsd_QName("test:deepc_prop2")].order)
+        prop4a = r1[Xsd_QName("test:deepc_prop2")].prop
+        prop4b = r2[Xsd_QName("test:deepc_prop2")].prop
         self.assertEqual(prop4a[PropClassAttr.IN], prop4b[PropClassAttr.IN])
 
     def test_reading_sys(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._sysproject,
-                                owl_class_iri=Iri('oldap:User'),
+                                owl_class_iri=Xsd_QName('oldap:User'),
                                 ignore_cache=True)
-        self.assertEqual(r1.owl_class_iri, Iri('oldap:User'))
+        self.assertEqual(r1.owl_class_iri, Xsd_QName('oldap:User'))
         self.assertEqual(r1.version, SemanticVersion(0, 1, 0))
         self.assertEqual(r1.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(r1.created, Xsd_dateTime('2023-11-04T12:00:00Z'))
         self.assertEqual(r1.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(r1.modified, Xsd_dateTime('2023-11-04T12:00:00Z'))
 
-        prop1 = r1[Iri('dcterms:creator')]
+        prop1 = r1[Xsd_QName('dcterms:creator')]
         self.assertEqual(prop1.minCount, Xsd_integer(1))
         self.assertEqual(prop1.maxCount, Xsd_integer(1))
-        self.assertEqual(prop1.prop.property_class_iri, Iri('dcterms:creator'))
-        self.assertEqual(prop1.prop.toClass, Iri('oldap:User'))
+        self.assertEqual(prop1.prop.property_class_iri, Xsd_QName('dcterms:creator'))
+        self.assertEqual(prop1.prop.toClass, Xsd_QName('oldap:User'))
 
-        prop2 = r1[Iri('dcterms:created')]
+        prop2 = r1[Xsd_QName('dcterms:created')]
         self.assertEqual(prop2.minCount, Xsd_integer(1))
         self.assertEqual(prop2.maxCount, Xsd_integer(1))
-        self.assertEqual(prop2.prop.property_class_iri, Iri('dcterms:created'))
+        self.assertEqual(prop2.prop.property_class_iri, Xsd_QName('dcterms:created'))
         self.assertEqual(prop2.prop.datatype, XsdDatatypes.dateTime)
 
-        prop3 = r1[Iri('dcterms:contributor')]
+        prop3 = r1[Xsd_QName('dcterms:contributor')]
         self.assertEqual(prop3.minCount, Xsd_integer(1))
         self.assertEqual(prop3.maxCount, Xsd_integer(1))
-        self.assertEqual(prop3.prop.property_class_iri, Iri('dcterms:contributor'))
+        self.assertEqual(prop3.prop.property_class_iri, Xsd_QName('dcterms:contributor'))
         self.assertEqual(prop3.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop3.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop3.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop3.prop.modified, Xsd_dateTime('2023-11-04T12:00:00Z'))
-        self.assertEqual(prop3.prop.toClass, Iri('oldap:User'))
+        self.assertEqual(prop3.prop.toClass, Xsd_QName('oldap:User'))
 
-        prop4 = r1[Iri('dcterms:modified')]
+        prop4 = r1[Xsd_QName('dcterms:modified')]
         self.assertEqual(prop4.minCount, Xsd_integer(1))
         self.assertEqual(prop4.maxCount, Xsd_integer(1))
-        self.assertEqual(prop4.prop.property_class_iri, Iri('dcterms:modified'))
+        self.assertEqual(prop4.prop.property_class_iri, Xsd_QName('dcterms:modified'))
         self.assertEqual(prop4.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop4.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop4.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop4.prop.modified, Xsd_dateTime('2023-11-04T12:00:00Z'))
         self.assertEqual(prop4.prop.datatype, XsdDatatypes.dateTime)
 
-        prop5 = r1[Iri('oldap:userId')]
+        prop5 = r1[Xsd_QName('oldap:userId')]
         self.assertEqual(prop5.minCount, Xsd_integer(1))
         self.assertEqual(prop5.maxCount, Xsd_integer(1))
-        self.assertEqual(prop5.prop.property_class_iri, Iri('oldap:userId'))
+        self.assertEqual(prop5.prop.property_class_iri, Xsd_QName('oldap:userId'))
         self.assertEqual(prop5.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop5.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop5.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
@@ -569,10 +569,10 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop5.prop.minLength, Xsd_integer(3))
         self.assertEqual(prop5.prop.maxLength, Xsd_integer(32))
 
-        prop6 = r1[Iri('schema:familyName')]
+        prop6 = r1[Xsd_QName('schema:familyName')]
         self.assertEqual(prop6.minCount, Xsd_integer(1))
         self.assertEqual(prop6.maxCount, Xsd_integer(1))
-        self.assertEqual(prop6.prop.property_class_iri, Iri('schema:familyName'))
+        self.assertEqual(prop6.prop.property_class_iri, Xsd_QName('schema:familyName'))
         self.assertEqual(prop6.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop6.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop6.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
@@ -581,10 +581,10 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop6.prop.name, LangString(["Family name@en", "Familiennamen@de", "Nom de famillie@fr", "Nome della famiglia@it"]))
         self.assertEqual(prop6.prop.description, LangString("The family name of some person.@en"))
 
-        prop7 = r1[Iri('schema:givenName')]
+        prop7 = r1[Xsd_QName('schema:givenName')]
         self.assertEqual(prop7.minCount, Xsd_integer(1))
         self.assertEqual(prop7.maxCount, Xsd_integer(1))
-        self.assertEqual(prop7.prop.property_class_iri, Iri('schema:givenName'))
+        self.assertEqual(prop7.prop.property_class_iri, Xsd_QName('schema:givenName'))
         self.assertEqual(prop7.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop7.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop7.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
@@ -593,10 +593,10 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop7.prop.name, LangString(["Given name@en", "Vornamen@de", "Prénom@fr", "Nome@it"]))
         self.assertEqual(prop7.prop.description, LangString("The given name of some person@en"))
 
-        prop8 = r1[Iri('oldap:credentials')]
+        prop8 = r1[Xsd_QName('oldap:credentials')]
         self.assertEqual(prop8.minCount, Xsd_integer(1))
         self.assertEqual(prop8.maxCount, Xsd_integer(1))
-        self.assertEqual(prop8.prop.property_class_iri, Iri('oldap:credentials'))
+        self.assertEqual(prop8.prop.property_class_iri, Xsd_QName('oldap:credentials'))
         self.assertEqual(prop8.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop8.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop8.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
@@ -605,18 +605,18 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop8.prop.name, LangString(["Password@en", "Passwort@de", "Mot de passe@fr", "Password@it"]))
         self.assertEqual(prop8.prop.description, LangString("Password for user.@en"))
 
-        prop9 = r1[Iri('oldap:inProject')]
-        self.assertEqual(prop9.prop.property_class_iri, Iri('oldap:inProject'))
+        prop9 = r1[Xsd_QName('oldap:inProject')]
+        self.assertEqual(prop9.prop.property_class_iri, Xsd_QName('oldap:inProject'))
         self.assertEqual(prop9.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop9.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop9.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop9.prop.modified, Xsd_dateTime('2023-11-04T12:00:00Z'))
-        self.assertEqual(prop9.prop.toClass, Iri('oldap:Project'))
+        self.assertEqual(prop9.prop.toClass, Xsd_QName('oldap:Project'))
 
-        prop10 = r1[Iri('oldap:isActive')]
+        prop10 = r1[Xsd_QName('oldap:isActive')]
         self.assertEqual(prop10.minCount, Xsd_integer(1))
         self.assertEqual(prop10.maxCount, Xsd_integer(1))
-        self.assertEqual(prop10.prop.property_class_iri, Iri('oldap:isActive'))
+        self.assertEqual(prop10.prop.property_class_iri, Xsd_QName('oldap:isActive'))
         self.assertEqual(prop10.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop10.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop10.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
@@ -625,21 +625,21 @@ class TestResourceClass(unittest.TestCase):
         self.assertIsNone(prop10.prop.name)
         self.assertIsNone(prop10.prop.description)
 
-        prop11 = r1[Iri('oldap:hasPermissions')]
-        self.assertEqual(prop11.prop.property_class_iri, Iri('oldap:hasPermissions'))
+        prop11 = r1[Xsd_QName('oldap:hasPermissions')]
+        self.assertEqual(prop11.prop.property_class_iri, Xsd_QName('oldap:hasPermissions'))
         self.assertEqual(prop11.prop.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop11.prop.created, Xsd_dateTime('2023-11-04T12:00:00+00:00'))
         self.assertEqual(prop11.prop.contributor, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop11.prop.modified, Xsd_dateTime('2023-11-04T12:00:00Z'))
-        self.assertEqual(prop11.prop.toClass, Iri('oldap:PermissionSet'))
+        self.assertEqual(prop11.prop.toClass, Xsd_QName('oldap:PermissionSet'))
 
     # @unittest.skip('Work in progress')
     def test_reading(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:testMyRes'),
+                                owl_class_iri=Xsd_QName('test:testMyRes'),
                                 ignore_cache=True)
-        self.assertEqual(r1.owl_class_iri, Iri('test:testMyRes'))
+        self.assertEqual(r1.owl_class_iri, Xsd_QName('test:testMyRes'))
         #self.assertEqual(r1.version, SemanticVersion(0, 1, 0))
         self.assertEqual(r1.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(r1.created, Xsd_dateTime('2023-11-04T12:00:00Z'))
@@ -649,9 +649,9 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(r1.comment, LangString("Resource for testing..."))
         self.assertTrue(r1.closed)
 
-        prop1 = r1[Iri('test:test')].prop
+        prop1 = r1[Xsd_QName('test:test')].prop
         self.assertIsNone(prop1.internal)
-        self.assertEqual(prop1.property_class_iri, Iri("test:test"))
+        self.assertEqual(prop1.property_class_iri, Xsd_QName("test:test"))
         #self.assertEqual(prop1.version, SemanticVersion(0, 1, 0))
         self.assertEqual(prop1.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop1.created, Xsd_dateTime('2023-11-04T12:00:00Z'))
@@ -660,12 +660,12 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
         self.assertEqual(prop1.datatype, XsdDatatypes.string)
         self.assertEqual(prop1.description, LangString("Property shape for testing purposes"))
-        self.assertEqual(r1[Iri('test:test')].minCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri('test:test')].order, Xsd_decimal(3))
+        self.assertEqual(r1[Xsd_QName('test:test')].minCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName('test:test')].order, Xsd_decimal(3))
 
-        prop2 = r1[Iri('test:hasText')].prop
-        self.assertEqual(prop2.internal, Iri('test:testMyRes'))
-        self.assertEqual(prop2.property_class_iri, Iri("test:hasText"))
+        prop2 = r1[Xsd_QName('test:hasText')].prop
+        self.assertEqual(prop2.internal, Xsd_QName('test:testMyRes'))
+        self.assertEqual(prop2.property_class_iri, Xsd_QName("test:hasText"))
         #self.assertEqual(prop2.version, SemanticVersion(1, 0, 0))
         self.assertEqual(prop2.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop2.created, Xsd_dateTime('2023-11-04T12:00:00Z'))
@@ -675,11 +675,11 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(prop2.datatype, XsdDatatypes.langString)
         self.assertEqual(prop2.name, LangString(["A text@en", "Ein Text@de"]))
         self.assertEqual(prop2.description, LangString("A longer text..."))
-        self.assertEqual(r1[Iri('test:hasText')].minCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri('test:hasText')].maxCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri('test:hasText')].order, Xsd_decimal(1))
+        self.assertEqual(r1[Xsd_QName('test:hasText')].minCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName('test:hasText')].maxCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName('test:hasText')].order, Xsd_decimal(1))
 
-        prop3 = r1[Iri('test:hasEnum')].prop
+        prop3 = r1[Xsd_QName('test:hasEnum')].prop
         self.assertEqual(prop3.type, OwlPropertyType.OwlDataProperty)
         self.assertEqual(prop3.datatype, XsdDatatypes.string)
         self.assertEqual(prop3.inSet,
@@ -688,23 +688,23 @@ class TestResourceClass(unittest.TestCase):
     def test_resource_jsonify(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:testMyRes'),
+                                owl_class_iri=Xsd_QName('test:testMyRes'),
                                 ignore_cache=True)
         jsonstr = json.dumps(r1, default=serializer.encoder_default, indent=3)
         r2 = json.loads(jsonstr, object_hook=serializer.make_decoder_hook(connection=self._connection))
-        self.assertEqual(r2.owl_class_iri, Iri('test:testMyRes'))
+        self.assertEqual(r2.owl_class_iri, Xsd_QName('test:testMyRes'))
         #self.assertEqual({Iri('test:testMyResMinimal'), Iri('oldap:Thing')}, {x for x in r2.superclass})
         self.assertEqual(r2.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertTrue(r2.closed)
 
-        hp1 = r2[Iri('test:test')]
+        hp1 = r2[Xsd_QName('test:test')]
         self.assertEqual(hp1.minCount, Xsd_integer(1))
         self.assertEqual(hp1.maxCount, Xsd_integer(1))
         self.assertEqual(hp1.order, Xsd_decimal(3))
         p1 = hp1.prop
         self.assertIsNone(p1.internal)
 
-        hp2 = r2[Iri('test:hasText')]
+        hp2 = r2[Xsd_QName('test:hasText')]
         self.assertEqual(hp2.minCount, Xsd_integer(1))
         self.assertEqual(hp2.maxCount, Xsd_integer(1))
         self.assertEqual(hp2.order, Xsd_decimal(1))
@@ -715,7 +715,7 @@ class TestResourceClass(unittest.TestCase):
         self.assertEqual(p2.name, LangString("A text@en", "Ein Text@de"))
         self.assertEqual(p2.description, LangString("A longer text...@en"))
 
-        hp3 = r2[Iri('test:hasEnum')]
+        hp3 = r2[Xsd_QName('test:hasEnum')]
         p3 = hp3.prop
         self.assertEqual(p3.datatype, XsdDatatypes.string)
         self.assertEqual(p3.inSet, {'blue', 'red', 'green', 'yellow'})
@@ -723,27 +723,27 @@ class TestResourceClass(unittest.TestCase):
     def test_reading_with_superclass(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:testMyResInherit'))
-        self.assertEqual(r1.owl_class_iri, Iri('test:testMyResInherit'))
-        self.assertEqual({Iri('test:testMyResMinimal'), Iri('oldap:Thing')}, {x for x in r1.superclass})
+                                owl_class_iri=Xsd_QName('test:testMyResInherit'))
+        self.assertEqual(r1.owl_class_iri, Xsd_QName('test:testMyResInherit'))
+        self.assertEqual({Xsd_QName('test:testMyResMinimal'), Xsd_QName('oldap:Thing')}, {x for x in r1.superclass})
 
     # @unittest.skip('Work in progress')
     def test_creating_empty_resource(self):
         r0 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResourceEmpty"))
+                           owlclass_iri=Xsd_QName("test:TestResourceEmpty"))
 
         r0.create()
 
     def test_creating_resource_incremental(self):
         r0 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResourceIncremental", validate=False))
+                           owlclass_iri=Xsd_QName("test:TestResourceIncremental", validate=False))
         r0.create()
 
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:testIncrementalProp1'),
+                           property_class_iri=Xsd_QName('test:testIncrementalProp1'),
                            subPropertyOf=Iri('test:comment'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["Test property@en", "Testprädikat@de"]),
@@ -751,27 +751,27 @@ class TestResourceClass(unittest.TestCase):
                            uniqueLang=Xsd_boolean(True),
                            languageIn=LanguageIn(Language.EN, Language.DE, Language.FR, Language.IT))
         hp1 = HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, order=1.0)
-        r0[Iri('test:testIncrementalProp1')] = hp1
+        r0[Xsd_QName('test:testIncrementalProp1')] = hp1
         r0.update()
 
         r0 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:TestResourceIncremental", validate=False))
-        self.assertEqual(r0.owl_class_iri, Iri("test:TestResourceIncremental", validate=False))
-        self.assertTrue(Iri("oldap:Thing", validate=False) in r0.superclass)
-        hp1 = r0[Iri('test:testIncrementalProp1')]
+                                owl_class_iri=Xsd_QName("test:TestResourceIncremental", validate=False))
+        self.assertEqual(r0.owl_class_iri, Xsd_QName("test:TestResourceIncremental", validate=False))
+        self.assertTrue(Xsd_QName("oldap:Thing", validate=False) in r0.superclass)
+        hp1 = r0[Xsd_QName('test:testIncrementalProp1')]
         self.assertEqual(hp1.minCount, 1)
         self.assertIsNone(hp1.maxCount)
         self.assertEqual(hp1.order, 1.0)
-        self.assertEqual(hp1.prop.property_class_iri, Iri("test:testIncrementalProp1", validate=False))
-        self.assertEqual(hp1.prop.subPropertyOf, Iri("test:comment"))
+        self.assertEqual(hp1.prop.property_class_iri, Xsd_QName("test:testIncrementalProp1", validate=False))
+        self.assertEqual(hp1.prop.subPropertyOf, Xsd_QName("test:comment"))
         self.assertEqual(hp1.prop.datatype, XsdDatatypes.langString)
 
     # TODO: Start systematic testing here!!!!!!!!!!!!¨
     def test_creating(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:testone'),
+                           property_class_iri=Xsd_QName('test:testone'),
                            subPropertyOf=Iri('test:comment'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["Test property@en", "Testprädikat@de"]),
@@ -781,29 +781,29 @@ class TestResourceClass(unittest.TestCase):
 
         p2 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:testtwo'),
-                           toClass=Iri('test:testMyRes'),
+                           property_class_iri=Xsd_QName('test:testtwo'),
+                           toClass=Xsd_QName('test:testMyRes'),
                            name=LangString(["Excl. Test property@en", "Exkl. Testprädikat@de"]),
                            description=LangString("An exclusive property for testing...@en"))
 
         p3 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:testthree'),
+                           property_class_iri=Xsd_QName('test:testthree'),
                            datatype=XsdDatatypes.int,
                            name=LangString(["E.N.U.M@en"]),
                            description=LangString("An exclusive enum testing...@en"),
                            inSet=RdfSet(Xsd_integer(1), Xsd_integer(2), Xsd_integer(3)))
 
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), maxCount=1, order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:test"), minCount=1, order=2),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:test"), minCount=1, order=2),
             HasProperty(con=self._connection, project=self._project, prop=p1, minCount=1, maxCount=1, order=3),
             HasProperty(con=self._connection, project=self._project, prop=p2, minCount=1, order=4),
             HasProperty(con=self._connection, project=self._project, prop=p3, maxCount=1, order=5)
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResource"),
+                           owlclass_iri=Xsd_QName("test:TestResource"),
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -811,59 +811,59 @@ class TestResourceClass(unittest.TestCase):
         r1.create()
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:TestResource"))
+                                owl_class_iri=Xsd_QName("test:TestResource"))
         self.assertEqual(r2.owl_class_iri, Xsd_QName("test:TestResource"))
         self.assertEqual(r2.label, LangString(["CreateResTest@en", "CréationResTeste@fr"]))
         self.assertEqual(r2.comment, LangString("For testing purposes@en"))
         self.assertTrue(r2.closed)
 
-        prop1 = r2[Iri("test:comment")].prop
+        prop1 = r2[Xsd_QName("test:comment")].prop
         self.assertIsNone(prop1.internal)
-        self.assertEqual(prop1.property_class_iri, Iri('test:comment'))
+        self.assertEqual(prop1.property_class_iri, Xsd_QName('test:comment'))
         self.assertEqual(prop1.datatype, XsdDatatypes.langString)
         self.assertTrue(prop1.uniqueLang)
-        self.assertEqual(r2[Iri("test:comment")].maxCount, Xsd_integer(1))
+        self.assertEqual(r2[Xsd_QName("test:comment")].maxCount, Xsd_integer(1))
         self.assertEqual(prop1.name, LangString(["comment@en", "Kommentar@de"]))
         self.assertEqual(prop1.description, LangString("This is a test property@de"))
         self.assertIsNone(prop1.subPropertyOf)
         self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
         self.assertEqual(prop1.creator, Iri('https://orcid.org/0000-0003-1681-4036'))
         self.assertEqual(prop1.created, Xsd_dateTime("2023-11-04T12:00:00Z"))
-        self.assertEqual(r2[Iri("test:comment")].order, Xsd_decimal(1))
+        self.assertEqual(r2[Xsd_QName("test:comment")].order, Xsd_decimal(1))
 
-        prop2 = r2[Iri("test:test")].prop
+        prop2 = r2[Xsd_QName("test:test")].prop
         self.assertIsNone(prop1.internal)
-        self.assertEqual(prop2.property_class_iri, Iri('test:test'))
-        self.assertEqual(r2[Iri("test:test")].minCount, Xsd_integer(1))
+        self.assertEqual(prop2.property_class_iri, Xsd_QName('test:test'))
+        self.assertEqual(r2[Xsd_QName("test:test")].minCount, Xsd_integer(1))
         self.assertEqual(prop2.name, LangString("Test"))
         self.assertEqual(prop2.description, LangString("Property shape for testing purposes"))
         self.assertEqual(prop2.datatype, XsdDatatypes.string)
         self.assertEqual(prop2.type, OwlPropertyType.OwlDataProperty)
-        self.assertEqual(r2[Iri("test:test")].order, Xsd_decimal(2))
+        self.assertEqual(r2[Xsd_QName("test:test")].order, Xsd_decimal(2))
 
-        prop3 = r2[Iri("test:testone")].prop
-        self.assertEqual(prop3.internal, Iri("test:TestResource"))
-        self.assertEqual(prop3.property_class_iri, Iri("test:testone"))
+        prop3 = r2[Xsd_QName("test:testone")].prop
+        self.assertEqual(prop3.internal, Xsd_QName("test:TestResource"))
+        self.assertEqual(prop3.property_class_iri, Xsd_QName("test:testone"))
         self.assertEqual(prop3.datatype, XsdDatatypes.langString)
         self.assertEqual(prop3.name, LangString(["Test property@en", "Testprädikat@de"]))
         self.assertEqual(prop3.description, LangString("A property for testing...@en"))
-        self.assertEqual(r2[Iri("test:testone")].minCount, Xsd_integer(1))
-        self.assertEqual(r2[Iri("test:testone")].maxCount, Xsd_integer(1))
+        self.assertEqual(r2[Xsd_QName("test:testone")].minCount, Xsd_integer(1))
+        self.assertEqual(r2[Xsd_QName("test:testone")].maxCount, Xsd_integer(1))
         self.assertEqual(prop3.languageIn, LanguageIn(Language.EN, Language.DE, Language.FR, Language.IT))
         self.assertTrue(prop3.uniqueLang)
-        self.assertEqual(r2[Iri("test:testone")].order, Xsd_decimal(3))
+        self.assertEqual(r2[Xsd_QName("test:testone")].order, Xsd_decimal(3))
 
-        prop4 = r2[Iri("test:testtwo")].prop
-        self.assertEqual(prop4.internal, Iri("test:TestResource"))
-        self.assertEqual(prop4.property_class_iri, Iri("test:testtwo"))
-        self.assertEqual(prop4.toClass, Iri('test:testMyRes'))
+        prop4 = r2[Xsd_QName("test:testtwo")].prop
+        self.assertEqual(prop4.internal, Xsd_QName("test:TestResource"))
+        self.assertEqual(prop4.property_class_iri, Xsd_QName("test:testtwo"))
+        self.assertEqual(prop4.toClass, Xsd_QName('test:testMyRes'))
         self.assertEqual(prop4.name, LangString(["Excl. Test property@en", "Exkl. Testprädikat@de"]))
         self.assertEqual(prop4.description, LangString("An exclusive property for testing...@en"))
-        self.assertEqual(r2[Iri("test:testtwo")].minCount, Xsd_integer(1))
-        self.assertEqual(r2[Iri("test:testtwo")].order, Xsd_decimal(4))
+        self.assertEqual(r2[Xsd_QName("test:testtwo")].minCount, Xsd_integer(1))
+        self.assertEqual(r2[Xsd_QName("test:testtwo")].order, Xsd_decimal(4))
 
-        prop5 = r2[Iri("test:testthree")].prop
-        self.assertEqual(prop5.internal, Iri("test:TestResource"))
+        prop5 = r2[Xsd_QName("test:testthree")].prop
+        self.assertEqual(prop5.internal, Xsd_QName("test:TestResource"))
         self.assertEqual(prop5.inSet, RdfSet(Xsd_integer(1), Xsd_integer(2), Xsd_integer(3)))
         # r2[Iri("test:testthree")].prop.inSet.add(Xsd_integer(4))
         # del r2[Iri("test:testthree")].maxCount
@@ -876,8 +876,8 @@ class TestResourceClass(unittest.TestCase):
     def test_creating_nopermission(self):
         p1 = PropertyClass(con=self._unpriv,
                            project=self._project,
-                           property_class_iri=Iri('test:testone_np'),
-                           subPropertyOf=Iri('test:comment'),
+                           property_class_iri=Xsd_QName('test:testone_np'),
+                           subPropertyOf=Xsd_QName('test:comment'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["Test property@en", "Testprädikat@de"]),
                            description=LangString("A property for testing...@en"),
@@ -886,29 +886,29 @@ class TestResourceClass(unittest.TestCase):
 
         p2 = PropertyClass(con=self._unpriv,
                            project=self._project,
-                           property_class_iri=Iri('test:testtwo_np'),
-                           toClass=Iri('test:testMyRes'),
+                           property_class_iri=Xsd_QName('test:testtwo_np'),
+                           toClass=Xsd_QName('test:testMyRes'),
                            name=LangString(["Excl. Test property@en", "Exkl. Testprädikat@de"]),
                            description=LangString("An exclusive property for testing...@en"))
 
         p3 = PropertyClass(con=self._unpriv,
                            project=self._project,
-                           property_class_iri=Iri('test:testthree_np'),
+                           property_class_iri=Xsd_QName('test:testthree_np'),
                            datatype=XsdDatatypes.int,
                            name=LangString(["E.N.U.M@en"]),
                            description=LangString("An exclusive enum testing...@en"),
                            inSet=RdfSet(Xsd_integer(1), Xsd_integer(2), Xsd_integer(3)))
 
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._unpriv, project=self._project, prop=Iri("test:comment"), maxCount=1, order=1),
-            HasProperty(con=self._unpriv, project=self._project, prop=Iri("test:test"), minCount=1, order=2),
+            HasProperty(con=self._unpriv, project=self._project, prop=Xsd_QName("test:comment"), maxCount=1, order=1),
+            HasProperty(con=self._unpriv, project=self._project, prop=Xsd_QName("test:test"), minCount=1, order=2),
             HasProperty(con=self._unpriv, project=self._project, prop=p1, minCount=1, maxCount=1, order=3),
             HasProperty(con=self._unpriv, project=self._project, prop=p2, minCount=1, order=4),
             HasProperty(con=self._unpriv, project=self._project, prop=p3, order=5)
         ]
         r1 = ResourceClass(con=self._unpriv,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResource_np"),
+                           owlclass_iri=Xsd_QName("test:TestResource_np"),
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -917,11 +917,11 @@ class TestResourceClass(unittest.TestCase):
         with self.assertRaises(OldapErrorNoPermission):
             r1.create()
 
-
     def test_creating_with_superclass(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:sctest_prop1'),
+                           property_class_iri=Xsd_QName('test:sctest_prop1'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["TestProp1"]))
         hasproperties: list[HasProperty] = [
@@ -929,8 +929,8 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:ResWithSuperclasses"),
-                           superclass={"test:testMyResMinimal", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'},
+                           owlclass_iri=Xsd_QName("test:ResWithSuperclasses"),
+                           superclass={"test:testMyResMinimal", 'crm:E22_Man-Made_Object'},
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -938,35 +938,36 @@ class TestResourceClass(unittest.TestCase):
         r1.create()
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:ResWithSuperclasses'))
+                                owl_class_iri=Xsd_QName('test:ResWithSuperclasses'))
         s = set(r2.superclass.keys())
-        self.assertEqual({"oldap:Thing", "test:testMyResMinimal", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'}, s)
+        self.assertEqual({"oldap:Thing", "test:testMyResMinimal", 'crm:E22_Man-Made_Object'}, s)
 
     def test_updating_superclass_add(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:Superclass1"),
+                           owlclass_iri=Xsd_QName("test:Superclass1"),
                            label=LangString(["Superclass1@en", "Superclass1@fr"]),
                            closed=Xsd_boolean(True))
         r1.create()
 
         r2 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:Superclass2"),
+                           owlclass_iri=Xsd_QName("test:Superclass2"),
                            label=LangString(["Superclass2@en", "Superclass2@fr"]),
                            closed=Xsd_boolean(True))
         r2.create()
 
         r3 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:Superclass3"),
+                           owlclass_iri=Xsd_QName("test:Superclass3"),
                            label=LangString(["Superclass2@en", "Superclass2@fr"]),
                            closed=Xsd_boolean(True))
         r3.create()
 
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:thingtest_prop1'),
+                           property_class_iri=Xsd_QName('test:thingtest_prop1'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["ThingTestProp1"]))
         hasproperties: list[HasProperty] = [
@@ -974,8 +975,8 @@ class TestResourceClass(unittest.TestCase):
         ]
         r = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:ResWithSuperThingAdd"),
-                           superclass={'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object', "test:Superclass1"},
+                           owlclass_iri=Xsd_QName("test:ResWithSuperThingAdd"),
+                           superclass={'crm:E22_Man-Made_Object', "test:Superclass1"},
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -983,40 +984,41 @@ class TestResourceClass(unittest.TestCase):
         r.create()
         r = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:ResWithSuperThingAdd'))
+                                owl_class_iri=Xsd_QName('test:ResWithSuperThingAdd'))
         r.add_superclasses({'test:Superclass2', 'test:Superclass3'})
         r.update()
         r = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:ResWithSuperThingAdd'))
+                                owl_class_iri=Xsd_QName('test:ResWithSuperThingAdd'))
         s = set(r.superclass.keys())
-        self.assertEqual(s, {"oldap:Thing", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object', "test:Superclass1", "test:Superclass2", "test:Superclass3"})
+        self.assertEqual(s, {"oldap:Thing", 'crm:E22_Man-Made_Object', "test:Superclass1", "test:Superclass2", "test:Superclass3"})
 
     def test_updating_superclass_del(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:SuperclassDel1"),
+                           owlclass_iri=Xsd_QName("test:SuperclassDel1"),
                            label=LangString(["SuperclassDel1@en", "SuperclassDel1@fr"]),
                            closed=Xsd_boolean(True))
         r1.create()
 
         r2 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:SuperclassDel2"),
+                           owlclass_iri=Xsd_QName("test:SuperclassDel2"),
                            label=LangString(["SuperclassDel2@en", "SuperclassDel2@fr"]),
                            closed=Xsd_boolean(True))
         r2.create()
 
         r3 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:SuperclassDel3"),
+                           owlclass_iri=Xsd_QName("test:SuperclassDel3"),
                            label=LangString(["SuperclassDel3@en", "SuperclassDel3@fr"]),
                            closed=Xsd_boolean(True))
         r3.create()
 
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:deltest_prop1'),
+                           property_class_iri=Xsd_QName('test:deltest_prop1'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["DelTestProp1"]))
         hasproperties: list[HasProperty] = [
@@ -1024,9 +1026,9 @@ class TestResourceClass(unittest.TestCase):
         ]
         r = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:ResWithManySuper2"),
+                           owlclass_iri=Xsd_QName("test:ResWithManySuper2"),
                            superclass={
-                               'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object',
+                               'crm:E22_Man-Made_Object',
                                "test:SuperclassDel1",
                                "test:SuperclassDel2",
                                "test:SuperclassDel3"},
@@ -1037,19 +1039,20 @@ class TestResourceClass(unittest.TestCase):
         r.create()
         r = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:ResWithManySuper2"))
+                                owl_class_iri=Xsd_QName("test:ResWithManySuper2"))
         r.del_superclasses({'test:SuperclassDel1', 'test:SuperclassDel3'})
         r.update()
         r = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:ResWithManySuper2"))
+                                owl_class_iri=Xsd_QName("test:ResWithManySuper2"))
         s = set(r.superclass.keys())
-        self.assertEqual(s, {"oldap:Thing", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object', "test:SuperclassDel2"})
+        self.assertEqual(s, {"oldap:Thing", 'crm:E22_Man-Made_Object', "test:SuperclassDel2"})
 
     def test_creating_with_thing_sc(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:thingtest_prop1'),
+                           property_class_iri=Xsd_QName('test:thingtest_prop1'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["ThingTestProp1"]))
         hasproperties: list[HasProperty] = [
@@ -1057,8 +1060,8 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:ResWithSuperThing"),
-                           superclass={'oldap:Thing', 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'},
+                           owlclass_iri=Xsd_QName("test:ResWithSuperThing"),
+                           superclass={'oldap:Thing', 'crm:E22_Man-Made_Object'},
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -1066,19 +1069,19 @@ class TestResourceClass(unittest.TestCase):
         r1.create()
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:ResWithSuperThing'))
+                                owl_class_iri=Xsd_QName('test:ResWithSuperThing'))
         s = set(r2.superclass.keys())
-        self.assertEqual({'oldap:Thing', Iri('http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object')}, s)
+        self.assertEqual({'oldap:Thing', Xsd_QName('crm:E22_Man-Made_Object')}, s)
 
     # @unittest.skip('Work in progress')
     def test_double_creation(self):
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment")),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:test")),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment")),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:test")),
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:testMyResMinimal"),
+                           owlclass_iri=Xsd_QName("test:testMyResMinimal"),
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -1091,157 +1094,157 @@ class TestResourceClass(unittest.TestCase):
     def test_updating_resclass_attributes_add(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyRes"))
+                                owl_class_iri=Xsd_QName("test:testMyRes"))
         r1.label.add("labello@it")
         r1.update()
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyRes"))
+                                owl_class_iri=Xsd_QName("test:testMyRes"))
         self.assertEqual(r1.label, LangString("My Resource@en", "Meine Ressource@de", "Ma Resource@fr", "labello@it"))
 
     def test_updating_resclass_attributes(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyResMinimalA"))
+                                owl_class_iri=Xsd_QName("test:testMyResMinimalA"))
         #self.assertTrue(r1.closed)
         r1[ResClassAttribute.LABEL] = LangString(["Minimal Resource@en", "Kleinste Resource@de", "Plus petite ressource@fr"])
         r1[ResClassAttribute.COMMENT] = LangString("Eine Beschreibung einer minimalen Ressource")
-        r1[ResClassAttribute.SUPERCLASS] = Iri("test:testMyRes")
+        r1[ResClassAttribute.SUPERCLASS] = Xsd_QName("test:testMyRes")
         r1.update()
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyResMinimalA"))
+                                owl_class_iri=Xsd_QName("test:testMyResMinimalA"))
         self.assertEqual(LangString(["Minimal Resource@en", "Kleinste Resource@de", "Plus petite ressource@fr"]), r2.label)
         self.assertEqual(LangString("Eine Beschreibung einer minimalen Ressource"), r2.comment)
-        self.assertEqual({Iri('test:testMyRes'), Iri('oldap:Thing')}, set(r2.superclass))
+        self.assertEqual({Xsd_QName('test:testMyRes'), Xsd_QName('oldap:Thing')}, set(r2.superclass))
 
 
     def test_updating_add_ext_prop(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyResMinimalA"))
+                                owl_class_iri=Xsd_QName("test:testMyResMinimalA"))
         self.assertTrue(r1.closed)
 
         r1[ResClassAttribute.LABEL] = LangString(["Minimal Resource@en", "Kleinste Resource@de", "Plus petite ressource@fr"])
         r1[ResClassAttribute.COMMENT] = LangString("Eine Beschreibung einer minimalen Ressource")
-        r1[ResClassAttribute.SUPERCLASS] = Iri("test:testMyRes")
+        r1[ResClassAttribute.SUPERCLASS] = Xsd_QName("test:testMyRes")
         r1[ResClassAttribute.CLOSED] = Xsd_boolean(False)
 
         #
         # Add an external, shared property defined by its own sh:PropertyShape instance
         #
-        r1[Iri('test:test')] = HasProperty(con=self._connection,
+        r1[Xsd_QName('test:test')] = HasProperty(con=self._connection,
                                            project=self._project,
-                                           prop=Iri("test:test"),
+                                           prop=Xsd_QName("test:test"),
                                            minCount=1,
                                            order=3,
                                            notifier=r1.notifier,
-                                           notify_data=Iri("test:test"))
+                                           notify_data=Xsd_QName("test:test"))
         r1.update()
         del r1
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyResMinimalA"))
+                                owl_class_iri=Xsd_QName("test:testMyResMinimalA"))
         self.assertEqual(LangString(["Minimal Resource@en", "Kleinste Resource@de", "Plus petite ressource@fr"]), r2.label)
         self.assertEqual(LangString("Eine Beschreibung einer minimalen Ressource"), r2.comment)
-        self.assertEqual({Iri('test:testMyRes'), Iri('oldap:Thing')}, set(r2.superclass))
-        self.assertIsInstance(r2.superclass[Iri('test:testMyRes')], ResourceClass)
+        self.assertEqual({Xsd_QName('test:testMyRes'), Xsd_QName('oldap:Thing')}, set(r2.superclass))
+        self.assertIsInstance(r2.superclass[Xsd_QName('test:testMyRes')], ResourceClass)
         self.assertFalse(r2[ResClassAttribute.CLOSED])
 
-        prop1 = r2[Iri('test:test')].prop
+        prop1 = r2[Xsd_QName('test:test')].prop
         self.assertIsNone(prop1.internal)
-        self.assertEqual(prop1.property_class_iri, Iri('test:test'))
-        self.assertEqual(r2[Iri('test:test')].minCount, Xsd_integer(1))
+        self.assertEqual(prop1.property_class_iri, Xsd_QName('test:test'))
+        self.assertEqual(r2[Xsd_QName('test:test')].minCount, Xsd_integer(1))
         self.assertEqual(prop1.name, LangString("Test"))
         self.assertEqual(prop1.description, LangString("Property shape for testing purposes"))
         self.assertEqual(prop1.datatype, XsdDatatypes.string)
-        self.assertEqual(r2[Iri('test:test')].order, Xsd_decimal(3))
+        self.assertEqual(r2[Xsd_QName('test:test')].order, Xsd_decimal(3))
         self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
 
     def test_updating_add_int_prop(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyResMinimalB"))
+                                owl_class_iri=Xsd_QName("test:testMyResMinimalB"))
         self.assertTrue(r1.closed)
         r1[ResClassAttribute.LABEL] = LangString(["Minimal Resource@en", "Kleinste Resource@de", "Plus petite ressource@fr"])
         r1[ResClassAttribute.COMMENT] = LangString("Eine Beschreibung einer minimalen Ressource")
-        r1[ResClassAttribute.SUPERCLASS] = Iri("test:testMyRes")
+        r1[ResClassAttribute.SUPERCLASS] = Xsd_QName("test:testMyRes")
         r1[ResClassAttribute.CLOSED] = Xsd_boolean(False)
 
         p = PropertyClass(con=self._connection,
                           project=self._project,
-                          toClass=Iri('test:Person'))
-        r1[Iri('dcterms:contributor')] = HasProperty(con=self._connection, project=self._project, prop=p, maxCount=Xsd_integer(1))
+                          toClass=Xsd_QName('test:Person'))
+        r1[Xsd_QName('dcterms:contributor')] = HasProperty(con=self._connection, project=self._project, prop=p, maxCount=Xsd_integer(1))
 
         r1.update()
         del r1
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyResMinimalB"))
-        prop1 = r2[Iri('dcterms:contributor')].prop
+                                owl_class_iri=Xsd_QName("test:testMyResMinimalB"))
+        prop1 = r2[Xsd_QName('dcterms:contributor')].prop
         self.assertEqual(prop1.internal, Xsd_QName("test:testMyResMinimalB"))
         self.assertEqual(prop1.toClass, Xsd_QName('test:Person'))
-        self.assertEqual(r2[Iri('dcterms:contributor')].maxCount, Xsd_integer(1))
+        self.assertEqual(r2[Xsd_QName('dcterms:contributor')].maxCount, Xsd_integer(1))
         self.assertEqual(prop1.type, OwlPropertyType.OwlObjectProperty)
 
     # @unittest.skip('Work in progress')
     def test_updating_add(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyResMinimalC"))
+                                owl_class_iri=Xsd_QName("test:testMyResMinimalC"))
         self.assertTrue(r1.closed)
         r1[ResClassAttribute.LABEL] = LangString(["Minimal Resource@en", "Kleinste Resource@de", "Plus petite ressource@fr"])
         r1[ResClassAttribute.COMMENT] = LangString("Eine Beschreibung einer minimalen Ressource")
-        r1[ResClassAttribute.SUPERCLASS] = Iri("test:testMyRes")
+        r1[ResClassAttribute.SUPERCLASS] = Xsd_QName("test:testMyRes")
         r1[ResClassAttribute.CLOSED] = Xsd_boolean(False)
 
         #
         # Add an external, shared property defined by its own sh:PropertyShape instance
         #
-        r1[Iri('test:test')] = HasProperty(con=self._connection, project=self._project, prop=Iri("test:test"), minCount=1, order=3)
+        r1[Xsd_QName('test:test')] = HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:test"), minCount=1, order=3)
 
         #
         # Adding an internal, private property
         #
         p = PropertyClass(con=self._connection,
                           project=self._project,
-                          toClass=Iri('test:Person'))
-        r1[Iri('dcterms:creator')] = HasProperty(con=self._connection, project=self._project, prop=p, maxCount=Xsd_integer(1))
+                          toClass=Xsd_QName('test:Person'))
+        r1[Xsd_QName('dcterms:creator')] = HasProperty(con=self._connection, project=self._project, prop=p, maxCount=Xsd_integer(1))
 
         p2 = PropertyClass(con=self._connection,
                            project=self._project,
                            datatype=XsdDatatypes.string,
                            inSet=RdfSet(Xsd_string('A'), Xsd_string('B'), Xsd_string('C'), Xsd_string('D'))
                            )
-        r1[Iri('test:color')] = HasProperty(con=self._connection, project=self._project, prop=p2)
+        r1[Xsd_QName('test:color')] = HasProperty(con=self._connection, project=self._project, prop=p2)
         r1.update()
         del r1
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyResMinimalC"))
+                                owl_class_iri=Xsd_QName("test:testMyResMinimalC"))
         self.assertEqual(LangString(["Minimal Resource@en", "Kleinste Resource@de", "Plus petite ressource@fr"]), r2.label)
         self.assertEqual(LangString("Eine Beschreibung einer minimalen Ressource"), r2.comment)
-        self.assertEqual({Iri("oldap:Thing"), Iri("test:testMyRes")}, set(r2.superclass))
-        self.assertIsInstance(r2.superclass[Iri('test:testMyRes')], ResourceClass)
+        self.assertEqual({Xsd_QName("oldap:Thing"), Xsd_QName("test:testMyRes")}, set(r2.superclass))
+        self.assertIsInstance(r2.superclass[Xsd_QName('test:testMyRes')], ResourceClass)
         self.assertFalse(r2[ResClassAttribute.CLOSED])
 
-        prop1 = r2[Iri('test:test')].prop
+        prop1 = r2[Xsd_QName('test:test')].prop
         self.assertIsNone(prop1.internal)
-        self.assertEqual(prop1.property_class_iri, Iri('test:test'))
+        self.assertEqual(prop1.property_class_iri, Xsd_QName('test:test'))
         self.assertEqual(prop1.name, LangString("Test"))
         self.assertEqual(prop1.description, LangString("Property shape for testing purposes"))
         self.assertEqual(prop1.datatype, XsdDatatypes.string)
         self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
-        self.assertEqual(r2[Iri('test:test')].minCount, Xsd_integer(1))
-        self.assertEqual(r2[Iri('test:test')].order, Xsd_decimal(3))
+        self.assertEqual(r2[Xsd_QName('test:test')].minCount, Xsd_integer(1))
+        self.assertEqual(r2[Xsd_QName('test:test')].order, Xsd_decimal(3))
 
-        prop2 = r2[Iri('dcterms:creator')].prop
+        prop2 = r2[Xsd_QName('dcterms:creator')].prop
         self.assertEqual(prop2.internal, Xsd_QName("test:testMyResMinimalC"))
         self.assertEqual(prop2.toClass, Xsd_QName('test:Person'))
-        self.assertEqual(r2[Iri('dcterms:creator')].maxCount, Xsd_integer(1))
+        self.assertEqual(r2[Xsd_QName('dcterms:creator')].maxCount, Xsd_integer(1))
         self.assertEqual(prop1.type, OwlPropertyType.OwlDataProperty)
 
-        prop3 = r2[Iri('test:color')].prop
+        prop3 = r2[Xsd_QName('test:color')].prop
         self.assertEqual(prop3.internal, Xsd_QName("test:testMyResMinimalC"))
         self.assertEqual(prop3.inSet, RdfSet(Xsd_string('A'), Xsd_string('B'), Xsd_string('C'), Xsd_string('D')))
 
@@ -1308,38 +1311,39 @@ class TestResourceClass(unittest.TestCase):
     def test_updating(self):
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyRes"))
-        self.assertEqual(r1[Iri('test:hasText')].maxCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri('test:hasText')].minCount, Xsd_integer(1))
-        self.assertEqual(r1[Iri('test:hasText')].prop.languageIn, LanguageIn(Language.EN, Language.DE))
-        self.assertEqual(r1[Iri('test:hasText')].prop.name, LangString(["A text@en", "Ein Text@de"]))
+                                owl_class_iri=Xsd_QName("test:testMyRes"))
+        self.assertEqual(r1[Xsd_QName('test:hasText')].maxCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName('test:hasText')].minCount, Xsd_integer(1))
+        self.assertEqual(r1[Xsd_QName('test:hasText')].prop.languageIn, LanguageIn(Language.EN, Language.DE))
+        self.assertEqual(r1[Xsd_QName('test:hasText')].prop.name, LangString(["A text@en", "Ein Text@de"]))
 
         r1.label[Language.IT] = "La mia risorsa"
         r1.closed = Xsd_boolean(False)
-        r1[ResClassAttribute.SUPERCLASS] = {Iri("oldap:Thing"), Iri('dcterms:TopGaga')}
-        r1[Iri('test:hasText')].prop.name[Language.FR] = "Un Texte Français"
-        r1[Iri('test:hasText')].maxCount = Xsd_integer(12)  # TODO !!!!!!!!!!!!!!!!!!
-        r1[Iri('test:hasText')].prop.languageIn = LanguageIn(Language.DE, Language.FR, Language.IT)
-        r1[Iri('test:hasEnum')].prop.inSet = RdfSet(Xsd_string('L'), Xsd_string('a'), Xsd_string('b'))
+        r1[ResClassAttribute.SUPERCLASS] = {Xsd_QName("oldap:Thing"), Xsd_QName('dcterms:TopGaga')}
+        r1[Xsd_QName('test:hasText')].prop.name[Language.FR] = "Un Texte Français"
+        r1[Xsd_QName('test:hasText')].maxCount = Xsd_integer(12)  # TODO !!!!!!!!!!!!!!!!!!
+        r1[Xsd_QName('test:hasText')].prop.languageIn = LanguageIn(Language.DE, Language.FR, Language.IT)
+        r1[Xsd_QName('test:hasEnum')].prop.inSet = RdfSet(Xsd_string('L'), Xsd_string('a'), Xsd_string('b'))
 
         r1.update()
 
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:testMyRes"))
+                                owl_class_iri=Xsd_QName("test:testMyRes"))
         self.assertEqual(r2.label, LangString(["My Resource@en", "Meine Ressource@de", "Ma Resource@fr", "La mia risorsa@it"]))
         self.assertFalse(r2.closed)
-        self.assertEqual({Iri("oldap:Thing"), Iri('dcterms:TopGaga')}, set(r2.superclass))
-        self.assertIsNone(r2.superclass[Iri('dcterms:TopGaga')])
-        self.assertEqual(r2[Iri('test:hasText')].prop.name, LangString(["A text@en", "Ein Text@de", "Un Texte Français@fr"]))
-        self.assertEqual(r2[Iri('test:hasText')].maxCount, Xsd_integer(12))  # TODO !!!!!!!!!!!!!!!!
-        self.assertEqual(r2[Iri('test:hasText')].prop.languageIn, LanguageIn(Language.DE, Language.FR, Language.IT))
-        self.assertEqual(r2[Iri('test:hasEnum')].prop.inSet, RdfSet(Xsd_string('L'), Xsd_string('a'), Xsd_string('b')))
+        self.assertEqual({Xsd_QName("oldap:Thing"), Xsd_QName('dcterms:TopGaga')}, set(r2.superclass))
+        self.assertIsNone(r2.superclass[Xsd_QName('dcterms:TopGaga')])
+        self.assertEqual(r2[Xsd_QName('test:hasText')].prop.name, LangString(["A text@en", "Ein Text@de", "Un Texte Français@fr"]))
+        self.assertEqual(r2[Xsd_QName('test:hasText')].maxCount, Xsd_integer(12))  # TODO !!!!!!!!!!!!!!!!
+        self.assertEqual(r2[Xsd_QName('test:hasText')].prop.languageIn, LanguageIn(Language.DE, Language.FR, Language.IT))
+        self.assertEqual(r2[Xsd_QName('test:hasEnum')].prop.inSet, RdfSet(Xsd_string('L'), Xsd_string('a'), Xsd_string('b')))
 
     def test_updating_sc_A(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:p1'),
+                           property_class_iri=Xsd_QName('test:p1'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["P1"]))
         hasproperties: list[HasProperty] = [
@@ -1347,8 +1351,8 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:Crazy"),
-                           superclass={"oldap:Thing", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'},
+                           owlclass_iri=Xsd_QName("test:Crazy"),
+                           superclass={"oldap:Thing", 'crm:E22_Man-Made_Object'},
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -1357,19 +1361,20 @@ class TestResourceClass(unittest.TestCase):
         del r1
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:Crazy'))
-        del r1.superclass[Iri('http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object')]
+                                owl_class_iri=Xsd_QName('test:Crazy'))
+        del r1.superclass[Xsd_QName('crm:E22_Man-Made_Object')]
         r1.update()
         del r1
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:Crazy'))
+                                owl_class_iri=Xsd_QName('test:Crazy'))
         self.assertEqual({"oldap:Thing"}, set(r1.superclass))
 
     def test_updating_sc_B(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:p2'),
+                           property_class_iri=Xsd_QName('test:p2'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["P2"]))
         hasproperties: list[HasProperty] = [
@@ -1377,8 +1382,8 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:CrazyB"),
-                           superclass={"test:testMyRes", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object'},
+                           owlclass_iri=Xsd_QName("test:CrazyB"),
+                           superclass={"test:testMyRes", 'crm:E22_Man-Made_Object'},
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -1387,19 +1392,21 @@ class TestResourceClass(unittest.TestCase):
         del r1
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:CrazyB'))
-        del r1.superclass[Iri("test:testMyRes")]
+                                owl_class_iri=Xsd_QName('test:CrazyB'))
+        del r1.superclass[Xsd_QName("test:testMyRes")]
         r1.update()
         del r1
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:CrazyB'))
-        self.assertEqual({Iri("oldap:Thing"), Iri('http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object')}, set(r1.superclass))
+                                owl_class_iri=Xsd_QName('test:CrazyB'))
+        self.assertEqual({Xsd_QName("oldap:Thing"), Xsd_QName('crm:E22_Man-Made_Object')}, set(r1.superclass))
 
     def test_updating_sc_C(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
+        self._context[Xsd_NCName('gaga')] = NamespaceIRI('http://gaga.com/ns/')
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:p3'),
+                           property_class_iri=Xsd_QName('test:p3'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["P3"]))
         hasproperties: list[HasProperty] = [
@@ -1407,8 +1414,8 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:CrazyC"),
-                           superclass={"test:testMyRes", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object', 'test:testMyResMinimal'},
+                           owlclass_iri=Xsd_QName("test:CrazyC"),
+                           superclass={"test:testMyRes", 'crm:E22_Man-Made_Object', 'test:testMyResMinimal'},
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -1417,22 +1424,23 @@ class TestResourceClass(unittest.TestCase):
         del r1
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:CrazyC'))
+                                owl_class_iri=Xsd_QName('test:CrazyC'))
         del r1.superclass['test:testMyResMinimal']
-        r1.superclass[Iri('http://gugus.com/gaga/wird/nicht/gehen')] = None
+        r1.superclass[Xsd_QName('gaga:DasWirdNichtGehen')] = None
         r1.update()
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:CrazyC'))
+                                owl_class_iri=Xsd_QName('test:CrazyC'))
         self.assertEqual({"oldap:Thing",
                           "test:testMyRes",
-                          'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object',
-                          'http://gugus.com/gaga/wird/nicht/gehen'}, set(r1.superclass))
+                          'crm:E22_Man-Made_Object',
+                          'gaga:DasWirdNichtGehen'}, set(r1.superclass))
 
     def test_updating_sc_D(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:p4'),
+                           property_class_iri=Xsd_QName('test:p4'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["P4"]))
         hasproperties: list[HasProperty] = [
@@ -1440,8 +1448,8 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:CrazyD"),
-                           superclass={"test:testMyRes", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object', 'test:testMyResMinimal'},
+                           owlclass_iri=Xsd_QName("test:CrazyD"),
+                           superclass={"test:testMyRes", 'crm:E22_Man-Made_Object', 'test:testMyResMinimal'},
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -1452,13 +1460,14 @@ class TestResourceClass(unittest.TestCase):
         r1.update()
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:CrazyD'))
+                                owl_class_iri=Xsd_QName('test:CrazyD'))
         self.assertIsNone(r1[ResClassAttribute.LABEL])
 
     def test_updating_sc_E(self):
+        self._context[Xsd_NCName('crm')] = NamespaceIRI('http://www.cidoc-crm.org/cidoc-crm/')
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:p5'),
+                           property_class_iri=Xsd_QName('test:p5'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["P5"]))
         hasproperties: list[HasProperty] = [
@@ -1466,8 +1475,8 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:CrazyE"),
-                           superclass={"test:testMyRes", 'http://www.cidoc-crm.org/cidoc-crm/E22_Man-Made_Object', 'test:testMyResMinimal'},
+                           owlclass_iri=Xsd_QName("test:CrazyE"),
+                           superclass={"test:testMyRes", 'crm:E22_Man-Made_Object', 'test:testMyResMinimal'},
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
                            closed=Xsd_boolean(True),
@@ -1478,25 +1487,25 @@ class TestResourceClass(unittest.TestCase):
         r1.update()
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:CrazyE'))
+                                owl_class_iri=Xsd_QName('test:CrazyE'))
         self.assertIsNone(r1[ResClassAttribute.LABEL])
 
     def test_updating_sc_F(self):
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:CrazyF"),
+                           owlclass_iri=Xsd_QName("test:CrazyF"),
                            label=LangString(["LabelF english@en", "Label F french@fr"]),
                            comment=LangString("commentF english@en"))
         r1.create()
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:CrazyF'))
+                                owl_class_iri=Xsd_QName('test:CrazyF'))
         del r1.label[Language.EN]
         r1.label.add("Label F italian@it")
         r1.update()
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri('test:CrazyF'))
+                                owl_class_iri=Xsd_QName('test:CrazyF'))
         self.assertEqual(r1.label, LangString(["Label F french@fr", "Label F italian@it"]))
         #
         # Testing if also OWL ontology has been updated
@@ -1518,8 +1527,8 @@ class TestResourceClass(unittest.TestCase):
     def test_delete_props(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:propA'),
-                           subPropertyOf=Iri('test:comment'),
+                           property_class_iri=Xsd_QName('test:propA'),
+                           subPropertyOf=Xsd_QName('test:comment'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["Test property@en", "Testprädikat@de"]),
                            description=LangString("A property for testing...@en"),
@@ -1528,27 +1537,27 @@ class TestResourceClass(unittest.TestCase):
 
         p2 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:propB'),
-                           toClass=Iri('test:testMyRes'),
+                           property_class_iri=Xsd_QName('test:propB'),
+                           toClass=Xsd_QName('test:testMyRes'),
                            name=LangString(["Excl. Test property@en", "Exkl. Testprädikat@de"]),
                            description=LangString("An exclusive property for testing...@en"))
 
         p3 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:propC'),
+                           property_class_iri=Xsd_QName('test:propC'),
                            datatype=XsdDatatypes.int,
                            inSet=RdfSet(Xsd_integer(10), Xsd_integer(20), Xsd_integer(30)))
 
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:test"), order=2),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:test"), order=2),
             HasProperty(con=self._connection, project=self._project, prop=p1, maxCount=Xsd_integer(1), minCount=Xsd_integer(1), order=3),
             HasProperty(con=self._connection, project=self._project, prop=p2, minCount=Xsd_integer(1), order=4),
             HasProperty(con=self._connection, project=self._project, prop=p3, order=5),
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResourceDelProps"),
+                           owlclass_iri=Xsd_QName("test:TestResourceDelProps"),
                            superclass="test:testMyResMinimal",
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
@@ -1559,15 +1568,15 @@ class TestResourceClass(unittest.TestCase):
 
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:TestResourceDelProps"), ignore_cache=True)
-        del r2[Iri('test:propB')]
-        del r2[Iri("test:test")]  # OWL is not yet removed (rdfs:subClassOf is still there)
-        del r2[Iri('test:propC')]
+                                owl_class_iri=Xsd_QName("test:TestResourceDelProps"), ignore_cache=True)
+        del r2[Xsd_QName('test:propB')]
+        del r2[Xsd_QName("test:test")]  # OWL is not yet removed (rdfs:subClassOf is still there)
+        del r2[Xsd_QName('test:propC')]
         r2.update()
 
         r3 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:TestResourceDelProps"), ignore_cache=True)
+                                owl_class_iri=Xsd_QName("test:TestResourceDelProps"), ignore_cache=True)
 
         self.assertTrue(check_prop_empty(self._connection, self._context, Graph.SHACL, 'test:testMyResMinimal', 'test:propB'))
         self.assertTrue(check_prop_empty(self._connection, self._context, Graph.ONTO, 'test:testMyResMinimal', 'test:propB'))
@@ -1582,8 +1591,8 @@ class TestResourceClass(unittest.TestCase):
     def test_delete(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:deleteA'),
-                           subPropertyOf=Iri('test:comment'),
+                           property_class_iri=Xsd_QName('test:deleteA'),
+                           subPropertyOf=Xsd_QName('test:comment'),
                            datatype=XsdDatatypes.langString,
                            name=LangString(["Test property@en", "Testprädikat@de"]),
                            description=LangString("A property for testing...@en"),
@@ -1592,27 +1601,27 @@ class TestResourceClass(unittest.TestCase):
 
         p2 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:deleteB'),
+                           property_class_iri=Xsd_QName('test:deleteB'),
                            toClass=Iri('test:testMyRes'),
                            name=LangString(["Excl. Test property@en", "Exkl. Testprädikat@de"]),
                            description=LangString("A property for testing...@en"))
 
         p3 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:deleteC'),
+                           property_class_iri=Xsd_QName('test:deleteC'),
                            datatype=XsdDatatypes.int,
                            inSet=RdfSet(Xsd_integer(10), Xsd_integer(20), Xsd_integer(30)))
 
         hasproperties: list[HasProperty] = [
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:comment"), order=1),
-            HasProperty(con=self._connection, project=self._project, prop=Iri("test:test"), order=2),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:comment"), order=1),
+            HasProperty(con=self._connection, project=self._project, prop=Xsd_QName("test:test"), order=2),
             HasProperty(con=self._connection, project=self._project, prop=p1, maxCount=Xsd_integer(1), minCount=Xsd_integer(1), order=3),
             HasProperty(con=self._connection, project=self._project, prop=p2, minCount=Xsd_integer(1), order=4),
             HasProperty(con=self._connection, project=self._project, prop=p3, order=5)
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResourceDelete"),
+                           owlclass_iri=Xsd_QName("test:TestResourceDelete"),
                            superclass="test:testMyResMinimal",
                            label=LangString(["DeleteResTest@en", "EffaçerResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
@@ -1623,20 +1632,21 @@ class TestResourceClass(unittest.TestCase):
 
         r2 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:TestResourceDelete"))
+                                owl_class_iri=Xsd_QName("test:TestResourceDelete"))
         r2.delete()
 
         self.assertTrue(check_res_empty(self._connection, self._context, Graph.SHACL, 'test:TestResourceDelete'))
         self.assertTrue(check_res_empty(self._connection, self._context, Graph.ONTO, 'test:TestResourceDelete'))
         superclass = ResourceClass.read(con=self._connection,
                                         project=self._project,
-                                        owl_class_iri=Iri("test:testMyResMinimal"))
+                                        owl_class_iri=Xsd_QName("test:testMyResMinimal"))
         self.assertEqual(Iri("test:testMyResMinimal"), superclass.owl_class_iri)
 
+    # TODO!! TEST FAILES BECAUSE OF OBJECTFACTORY NOT YET FIXED!!!
     def test_in_use_case(self):
         p1 = PropertyClass(con=self._connection,
                            project=self._project,
-                           property_class_iri=Iri('test:prop_A'),
+                           property_class_iri=Xsd_QName('test:prop_A'),
                            datatype=XsdDatatypes.string,
                            name=LangString(["Test property A@en", "Testprädikat A@de"]),
                            description=LangString("A property for testing...@en"))
@@ -1646,7 +1656,7 @@ class TestResourceClass(unittest.TestCase):
         ]
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:TestResourceInUse"),
+                           owlclass_iri=Xsd_QName("test:TestResourceInUse"),
                            superclass="test:testMyResMinimal",
                            label=LangString(["CreateResTest@en", "CréationResTeste@fr"]),
                            comment=LangString("For testing purposes@en"),
@@ -1655,7 +1665,7 @@ class TestResourceClass(unittest.TestCase):
         r1.create()
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:TestResourceInUse"), ignore_cache=True)
+                                owl_class_iri=Xsd_QName("test:TestResourceInUse"), ignore_cache=True)
 
         factory = ResourceInstanceFactory(con=self._connection, project=self._project)
         TestResourceInUse = factory.createObjectInstance('TestResourceInUse')
@@ -1679,22 +1689,18 @@ class TestResourceClass(unittest.TestCase):
 
         r1 = ResourceClass.read(con=self._connection,
                                 project=self._project,
-                                owl_class_iri=Iri("test:TestResourceInUse"), ignore_cache=True)
+                                owl_class_iri=Xsd_QName("test:TestResourceInUse"), ignore_cache=True)
         r1.add_superclasses("dcterms:waseliwas")
         with self.assertRaises(OldapErrorInUse):
             r1.update()
 
 
-
-
-
-
-
     # @unittest.skip('Work in progress')
     def test_write_trig(self):
+        self._context[Xsd_NCName('andromeda')] = NamespaceIRI('http://andromeda.com/cluster1/')
         project_id = PropertyClass(con=self._connection,
                                    project=self._project,
-                                   property_class_iri=Iri('test:projectId'),
+                                   property_class_iri=Xsd_QName('test:projectId'),
                                    datatype=XsdDatatypes.langString,
                                    name=LangString(["Project ID@en", "Projekt ID@de"]),
                                    description=LangString(["Unique ID for project@en", "Eindeutige ID für Projekt@de"]),
@@ -1702,7 +1708,7 @@ class TestResourceClass(unittest.TestCase):
                                    uniqueLang=Xsd_boolean(True))
         project_name = PropertyClass(con=self._connection,
                                      project=self._project,
-                                     property_class_iri=Iri('test:projectName'),
+                                     property_class_iri=Xsd_QName('test:projectName'),
                                      datatype=XsdDatatypes.langString,
                                      name=LangString(["Project name@en", "Projektname@de"]),
                                      description=LangString(["A description of the project@en", "EineBeschreibung des Projekts@de"]),
@@ -1715,12 +1721,12 @@ class TestResourceClass(unittest.TestCase):
         ]
         superclass = ResourceClass.read(con=self._connection,
                                         project=self._project,
-                                        owl_class_iri=Iri("test:testMyResMinimal"))
+                                        owl_class_iri=Xsd_QName("test:testMyResMinimal"))
 
         r1 = ResourceClass(con=self._connection,
                            project=self._project,
-                           owlclass_iri=Iri("test:Project"),
-                           superclass={"test:testMyResMinimal", Iri('http://andromeda.com/cluster1/cepheid_42')},
+                           owlclass_iri=Xsd_QName("test:Project"),
+                           superclass={"test:testMyResMinimal", Xsd_QName('andromeda:Cepheid42')},
                            label=LangString(["Project@en", "Projekt@de"]),
                            comment=LangString(["Definiton of a project@en", "Definition eines Projektes@de"]),
                            closed=Xsd_boolean(True),
@@ -1730,7 +1736,7 @@ class TestResourceClass(unittest.TestCase):
         r1.update()
         r1.read(con=self._connection,
                 project=self._project,
-                owl_class_iri=Iri("test:Project"), ignore_cache=True)
+                owl_class_iri=Xsd_QName("test:Project"), ignore_cache=True)
         r1.write_as_trig("gaga.trig")