Merge remote-tracking branch 'upstream/master' into mark_ill_typed_literals

5 files changed, 58 insertions, 88 deletions

diff --git a/test/test_literal/test_datetime.py b/test/test_literal/test_datetime.py
index d71fc392..8f5e12ea 100644
--- a/test/test_literal/test_datetime.py
+++ b/test/test_literal/test_datetime.py
@@ -1,5 +1,4 @@
 import sys
-import unittest
 
 from datetime import datetime
 
@@ -11,13 +10,13 @@ from rdflib.term import Literal
 from rdflib.namespace import XSD
 
 
-class TestRelativeBase(unittest.TestCase):
+class TestRelativeBase:
     def test_equality(self):
         x = Literal(
             "2008-12-01T18:02:00Z",
             datatype=URIRef("http://www.w3.org/2001/XMLSchema#dateTime"),
         )
-        self.assertEqual(x == x, True)
+        assert x == x
 
     def test_microseconds(self):
         dt1 = datetime(2009, 6, 15, 23, 37, 6, 522630)
@@ -25,53 +24,46 @@ class TestRelativeBase(unittest.TestCase):
 
         # datetime with microseconds should be cast as a literal with using
         # XML Schema dateTime as the literal datatype
-        self.assertEqual(str(l), "2009-06-15T23:37:06.522630")
-        self.assertEqual(l.datatype, XSD.dateTime)
+        assert str(l) == "2009-06-15T23:37:06.522630"
+        assert l.datatype == XSD.dateTime
 
         dt2 = l.toPython()
-        self.assertEqual(dt2, dt1)
+        assert dt2 == dt1
 
     def test_to_python(self):
         dt = "2008-12-01T18:02:00"
         l = Literal(dt, datatype=URIRef("http://www.w3.org/2001/XMLSchema#dateTime"))
 
-        self.assertTrue(isinstance(l.toPython(), datetime))
-        self.assertEqual(l.toPython().isoformat(), dt)
+        assert isinstance(l.toPython(), datetime)
+        assert l.toPython().isoformat() == dt
 
     def test_timezone_z(self):
         dt = "2008-12-01T18:02:00.522630Z"
         l = Literal(dt, datatype=URIRef("http://www.w3.org/2001/XMLSchema#dateTime"))
 
-        self.assertTrue(isinstance(l.toPython(), datetime))
-        self.assertEqual(
-            datetime_isoformat(
-                l.toPython(), DATE_EXT_COMPLETE + "T" + "%H:%M:%S.%f" + TZ_EXT
-            ),
-            dt,
+        assert isinstance(l.toPython(), datetime)
+        assert datetime_isoformat(
+            l.toPython() == DATE_EXT_COMPLETE + "T" + "%H:%M:%S.%f" + TZ_EXT, dt
         )
-        self.assertEqual(l.toPython().isoformat(), "2008-12-01T18:02:00.522630+00:00")
+        assert l.toPython().isoformat() == "2008-12-01T18:02:00.522630+00:00"
 
     def test_timezone_offset(self):
         dt = "2010-02-10T12:36:00+03:00"
         l = Literal(dt, datatype=URIRef("http://www.w3.org/2001/XMLSchema#dateTime"))
 
-        self.assertTrue(isinstance(l.toPython(), datetime))
-        self.assertEqual(l.toPython().isoformat(), dt)
+        assert isinstance(l.toPython(), datetime)
+        assert l.toPython().isoformat() == dt
 
     def test_timezone_offset_to_utc(self):
         dt = "2010-02-10T12:36:00+03:00"
         l = Literal(dt, datatype=URIRef("http://www.w3.org/2001/XMLSchema#dateTime"))
 
         utc_dt = l.toPython().astimezone(UTC)
-        self.assertEqual(datetime_isoformat(utc_dt), "2010-02-10T09:36:00Z")
+        assert datetime_isoformat(utc_dt) == "2010-02-10T09:36:00Z"
 
     def test_timezone_offset_millisecond(self):
         dt = "2011-01-16T19:39:18.239743+01:00"
         l = Literal(dt, datatype=URIRef("http://www.w3.org/2001/XMLSchema#dateTime"))
 
-        self.assertTrue(isinstance(l.toPython(), datetime))
-        self.assertEqual(l.toPython().isoformat(), dt)
-
-
-if __name__ == "__main__":
-    unittest.main()
+        assert isinstance(l.toPython(), datetime)
+        assert l.toPython().isoformat() == dt
diff --git a/test/test_literal/test_duration.py b/test/test_literal/test_duration.py
index cdea7ab7..41062ef4 100644
--- a/test/test_literal/test_duration.py
+++ b/test/test_literal/test_duration.py
@@ -1,4 +1,3 @@
-import unittest
 from datetime import timedelta
 
 from isodate import Duration, parse_duration
@@ -7,40 +6,33 @@ from rdflib.namespace import XSD
 from rdflib.term import Literal
 
 
-class TestDuration(unittest.TestCase):
+class TestDuration:
     def test_to_python_timedelta(self):
         l = Literal("P4DT5H6M7S", datatype=XSD.dayTimeDuration)
-        self.assertTrue(isinstance(l.toPython(), timedelta))
-        self.assertEqual(l.toPython(), parse_duration("P4DT5H6M7S"))
+        assert isinstance(l.toPython(), timedelta)
+        assert l.toPython() == parse_duration("P4DT5H6M7S")
 
     def test_to_python_ym_duration(self):
         l = Literal("P1Y2M", datatype=XSD.yearMonthDuration)
-        self.assertTrue(isinstance(l.toPython(), Duration))
-        self.assertEqual(l.toPython(), parse_duration("P1Y2M"))
+        assert isinstance(l.toPython(), Duration)
+        assert l.toPython() == parse_duration("P1Y2M")
 
     def test_to_python_ymdhms_duration(self):
         l = Literal("P1Y2M4DT5H6M7S", datatype=XSD.duration)
-        self.assertTrue(isinstance(l.toPython(), Duration))
-        self.assertEqual(l.toPython(), parse_duration("P1Y2M4DT5H6M7S"))
+        assert isinstance(l.toPython(), Duration)
+        assert l.toPython() == parse_duration("P1Y2M4DT5H6M7S")
 
-    def test_equality(self):
+    def test_equalityself(self):
         x = Literal("P1Y2M3W4DT5H6M7S", datatype=XSD.duration)
         y = Literal("P1Y2M25DT5H6M7S", datatype=XSD.duration)
-        self.assertTrue(x == y)
+        assert x == y
 
     def test_duration_le(self):
-        self.assertTrue(
-            Literal("P4DT5H6M7S", datatype=XSD.duration)
-            < Literal("P8DT10H12M14S", datatype=XSD.duration)
+        assert Literal("P4DT5H6M7S", datatype=XSD.duration) < Literal(
+            "P8DT10H12M14S", datatype=XSD.duration
         )
 
     def test_duration_sum(self):
-        self.assertEqual(
-            Literal("P1Y2M4DT5H6M7S", datatype=XSD.duration)
-            + Literal("P1Y2M4DT5H6M7S", datatype=XSD.duration).toPython(),
-            Literal("P2Y4M8DT10H12M14S", datatype=XSD.duration),
-        )
-
-
-if __name__ == "__main__":
-    unittest.main()
+        assert Literal("P1Y2M4DT5H6M7S", datatype=XSD.duration) + Literal(
+            "P1Y2M4DT5H6M7S", datatype=XSD.duration
+        ).toPython() == Literal("P2Y4M8DT10H12M14S", datatype=XSD.duration)
diff --git a/test/test_literal/test_normalized_string.py b/test/test_literal/test_normalized_string.py
index 5c11c107..4aa979f0 100644
--- a/test/test_literal/test_normalized_string.py
+++ b/test/test_literal/test_normalized_string.py
@@ -1,36 +1,29 @@
-import unittest
-
 from rdflib import Literal
 from rdflib.namespace import XSD
 
 
-class NormalizedStringTest(unittest.TestCase):
+class TestNormalizedString:
     def test1(self):
         lit2 = Literal("\two\nw", datatype=XSD.normalizedString)
         lit = Literal("\two\nw", datatype=XSD.string)
-        self.assertFalse(str(lit) == str(lit2))
+        assert str(lit) != str(lit2)
 
     def test2(self):
         lit = Literal(
             "\tBeing a Doctor Is\n\ta Full-Time Job\r", datatype=XSD.normalizedString
         )
         st = Literal(" Being a Doctor Is  a Full-Time Job ", datatype=XSD.string)
-        self.assertFalse(Literal.eq(st, lit))
-        self.assertEqual(str(lit), str(st))
+        assert Literal.eq(st, lit) is False
+        assert str(lit) == str(st)
 
     def test3(self):
         lit = Literal("hey\nthere", datatype=XSD.normalizedString).n3()
-        self.assertTrue(
-            lit == '"hey there"^^<http://www.w3.org/2001/XMLSchema#normalizedString>'
-        )
+        assert lit == '"hey there"^^<http://www.w3.org/2001/XMLSchema#normalizedString>'
 
     def test4(self):
         lit = Literal(
             "hey\nthere\ta tab\rcarriage return", datatype=XSD.normalizedString
         )
         expected = Literal("""hey there a tab carriage return""", datatype=XSD.string)
-        self.assertEqual(str(lit), str(expected))
-
+        assert str(lit) == str(expected)
 
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/test_literal/test_term.py b/test/test_literal/test_term.py
index 0f9dbea2..6e0db827 100644
--- a/test/test_literal/test_term.py
+++ b/test/test_literal/test_term.py
@@ -3,7 +3,6 @@ some more specific Literal tests are in test_literal.py
 """
 
 import base64
-import unittest
 import random
 
 from rdflib.term import URIRef, BNode, Literal, _is_valid_unicode
@@ -15,19 +14,19 @@ def uformat(s):
     return s.replace("u'", "'")
 
 
-class TestURIRefRepr(unittest.TestCase):
+class TestURIRefRepr:
     """
     see also test_literal.TestRepr
     """
 
-    def testSubclassNameAppearsInRepr(self):
+    def test_subclass_name_appears_in_repr(self):
         class MyURIRef(URIRef):
             pass
 
         x = MyURIRef("http://example.com/")
-        self.assertEqual(repr(x), uformat("MyURIRef(u'http://example.com/')"))
+        assert repr(x) == uformat("MyURIRef(u'http://example.com/')")
 
-    def testGracefulOrdering(self):
+    def test_graceful_ordering(self):
         u = URIRef("cake")
         g = Graph()
         a = u > u
@@ -36,22 +35,21 @@ class TestURIRefRepr(unittest.TestCase):
         a = u > g
 
 
-class TestBNodeRepr(unittest.TestCase):
-    def testSubclassNameAppearsInRepr(self):
+class TestBNodeRepr:
+    def test_subclass_name_appears_in_repr(self):
         class MyBNode(BNode):
             pass
 
         x = MyBNode()
-        self.assertTrue(repr(x).startswith("MyBNode("))
+        assert repr(x).startswith("MyBNode(")
 
-
-class TestLiteral(unittest.TestCase):
+class TestLiteral:
     def test_base64_values(self):
         b64msg = "cmRmbGliIGlzIGNvb2whIGFsc28gaGVyZSdzIHNvbWUgYmluYXJ5IAAR83UC"
         decoded_b64msg = base64.b64decode(b64msg)
         lit = Literal(b64msg, datatype=XSD.base64Binary)
-        self.assertEqual(lit.value, decoded_b64msg)
-        self.assertEqual(str(lit), b64msg)
+        assert lit.value == decoded_b64msg
+        assert str(lit) == b64msg
 
     def test_total_order(self):
         types = {
@@ -78,7 +76,7 @@ class TestLiteral(unittest.TestCase):
                 print(repr(l_), repr(l_.value))
             print(e)
             orderable = False
-        self.assertTrue(orderable)
+        assert orderable is True
 
         # also make sure that within a datetime things are still ordered:
         l1 = [
@@ -101,7 +99,7 @@ class TestLiteral(unittest.TestCase):
         ]
         l2 = list(l1)
         random.shuffle(l2)
-        self.assertListEqual(l1, sorted(l2))
+        assert l1 == sorted(l2)
 
     def test_literal_add(self):
         from decimal import Decimal
@@ -267,10 +265,10 @@ class TestLiteral(unittest.TestCase):
                     + (case[1] + case[2]).datatype
                 )
 
-            self.assertTrue(case_passed, "Case " + str(case[0]) + " failed")
+            assert case_passed, "Case " + str(case[0]) + " failed"
 
 
-class TestValidityFunctions(unittest.TestCase):
+class TestValidityFunctions:
     def test_is_valid_unicode(self):
         testcase_list = (
             (None, True),
@@ -282,4 +280,4 @@ class TestValidityFunctions(unittest.TestCase):
             (b"foo\xf3\x02", False),
         )
         for val, expected in testcase_list:
-            self.assertEqual(_is_valid_unicode(val), expected)
+            assert _is_valid_unicode(val) == expected
diff --git a/test/test_literal/test_tokendatatype.py b/test/test_literal/test_tokendatatype.py
index 565f5972..83fe339e 100644
--- a/test/test_literal/test_tokendatatype.py
+++ b/test/test_literal/test_tokendatatype.py
@@ -1,28 +1,26 @@
-import unittest
-
 from rdflib import Literal, XSD
 
 
-class TokenDatatypeTest(unittest.TestCase):
+class TestTokenDatatype:
     def test1(self):
         lit2 = Literal("\two\nw", datatype=XSD.normalizedString)
         lit = Literal("\two\nw", datatype=XSD.string)
-        self.assertFalse(str(lit) == str(lit2))
+        assert str(lit) != str(lit2)
 
     def test2(self):
         lit = Literal("\tBeing a Doctor    Is\n\ta Full-Time Job\r", datatype=XSD.token)
         st = Literal("Being a Doctor Is a Full-Time Job", datatype=XSD.string)
-        self.assertFalse(Literal.eq(st, lit))
-        self.assertEqual(str(lit), str(st))
+        assert Literal.eq(st, lit) is False
+        assert str(lit) == str(st)
 
     def test3(self):
         lit = Literal("       hey\nthere      ", datatype=XSD.token).n3()
-        self.assertTrue(lit == '"hey there"^^<http://www.w3.org/2001/XMLSchema#token>')
+        assert lit == '"hey there"^^<http://www.w3.org/2001/XMLSchema#token>'
 
     def test4(self):
         lit = Literal("hey\nthere\ta tab\rcarriage return", datatype=XSD.token)
         expected = Literal("""hey there a tab carriage return""", datatype=XSD.string)
-        self.assertEqual(str(lit), str(expected))
+        assert str(lit) == str(expected)
 
     def test_whitespace_is_collapsed_and_trailing_whitespace_is_stripped(self):
         lit = Literal(
@@ -33,8 +31,5 @@ class TokenDatatypeTest(unittest.TestCase):
             "hey - white space is collapsed for xsd:token and preceding and trailing whitespace is stripped",
             datatype=XSD.string,
         )
-        self.assertEqual(str(lit), str(expected))
-
+        assert str(lit) == str(expected)
 
-if __name__ == "__main__":
-    unittest.main()