Adjust tests

Author: erlend-aasland

Lib/test/test_sqlite3/test_types.py

@@ -103,27 +103,29 @@ def test_string_with_surrogates(self):
         row = self.cur.fetchone()
         self.assertIsNone(row)
 
-    @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
-    @support.bigmemtest(size=2**31, memuse=4, dry_run=False)
+    @unittest.skipUnless(sys.maxsize > 2**64, 'requires (s)size_t > 64bit')
+    @support.bigmemtest(size=2**64+1, memuse=4, dry_run=False)
     def test_too_large_string(self, maxsize):
         with self.assertRaises(sqlite.DataError):
-            self.cur.execute("insert into test(s) values (?)", ('x'*(2**31-1),))
-        with self.assertRaises(sqlite.DataError):
-            self.cur.execute("insert into test(s) values (?)", ('x'*(2**31),))
+            self.cur.execute("insert into test(s) values (?)", ('x'*(2**64+1),))
         self.cur.execute("select 1 from test")
         row = self.cur.fetchone()
         self.assertIsNone(row)
+        self.cur.execute("insert into test(s) values (?)", ('x'*(2**64),))
+        row = self.cur.fetchone()
+        self.assertEqual(len(row), 1)
 
-    @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
-    @support.bigmemtest(size=2**31, memuse=3, dry_run=False)
+    @unittest.skipUnless(sys.maxsize > 2**64, 'requires (s)size_t > 64bit')
+    @support.bigmemtest(size=2**64+1, memuse=3, dry_run=False)
     def test_too_large_blob(self, maxsize):
         with self.assertRaises(sqlite.DataError):
-            self.cur.execute("insert into test(s) values (?)", (b'x'*(2**31-1),))
-        with self.assertRaises(sqlite.DataError):
-            self.cur.execute("insert into test(s) values (?)", (b'x'*(2**31),))
+            self.cur.execute("insert into test(s) values (?)", (b'x'*(2**64+1),))
         self.cur.execute("select 1 from test")
         row = self.cur.fetchone()
         self.assertIsNone(row)
+        self.cur.execute("insert into test(s) values (?)", (b'x'*(2**64),))
+        row = self.cur.fetchone()
+        self.assertEqual(len(row), 1)
 
 
 class DeclTypesTests(unittest.TestCase):

Lib/test/test_sqlite3/test_userfunctions.py

@@ -397,23 +397,21 @@ def test_func_return_text_with_surrogates(self):
             with self.assertRaises(sqlite.OperationalError):
                 cur.execute("select pychr(?)", (value,))
 
-    @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
-    @bigmemtest(size=2**31, memuse=3, dry_run=False)
+    @unittest.skipUnless(sys.maxsize > 2**64, 'requires (s)size_t > 64bit')
+    @bigmemtest(size=2**64+1, memuse=3, dry_run=False)
     def test_func_return_too_large_text(self, size):
         cur = self.con.cursor()
-        for size in 2**31-1, 2**31:
-            self.con.create_function("largetext", 0, lambda size=size: "b" * size)
-            with self.assertRaises(sqlite.DataError):
-                cur.execute("select largetext()")
+        self.con.create_function("largetext", 0, lambda: "b" * 2**64+1)
+        with self.assertRaises(sqlite.DataError):
+            cur.execute("select largetext()")
 
-    @unittest.skipUnless(sys.maxsize > 2**32, 'requires 64bit platform')
-    @bigmemtest(size=2**31, memuse=2, dry_run=False)
+    @unittest.skipUnless(sys.maxsize > 2**64, 'requires (s)size_t > 64bit')
+    @bigmemtest(size=2**64+1, memuse=2, dry_run=False)
     def test_func_return_too_large_blob(self, size):
         cur = self.con.cursor()
-        for size in 2**31-1, 2**31:
-            self.con.create_function("largeblob", 0, lambda size=size: b"b" * size)
-            with self.assertRaises(sqlite.DataError):
-                cur.execute("select largeblob()")
+        self.con.create_function("largeblob", 0, lambda: b"b" * 2**64+1)
+        with self.assertRaises(sqlite.DataError):
+            cur.execute("select largeblob()")
 
     def test_func_return_illegal_value(self):
         self.con.create_function("badreturn", 0, lambda: self)