removed /etc and /opt

opt/plesk/python/3/lib/python3.10/sqlite3/__init__.py

@@ -1,71 +0,0 @@
-# pysqlite2/__init__.py: the pysqlite2 package.
-#
-# Copyright (C) 2005 Gerhard Häring <gh@ghaering.de>
-#
-# This file is part of pysqlite.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-#    claim that you wrote the original software. If you use this software
-#    in a product, an acknowledgment in the product documentation would be
-#    appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-#    misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-"""
-The sqlite3 extension module provides a DB-API 2.0 (PEP 249) compliant
-interface to the SQLite library, and requires SQLite 3.7.15 or newer.
-
-To use the module, start by creating a database Connection object:
-
-    import sqlite3
-    cx = sqlite3.connect("test.db")  # test.db will be created or opened
-
-The special path name ":memory:" can be provided to connect to a transient
-in-memory database:
-
-    cx = sqlite3.connect(":memory:")  # connect to a database in RAM
-
-Once a connection has been established, create a Cursor object and call
-its execute() method to perform SQL queries:
-
-    cu = cx.cursor()
-
-    # create a table
-    cu.execute("create table lang(name, first_appeared)")
-
-    # insert values into a table
-    cu.execute("insert into lang values (?, ?)", ("C", 1972))
-
-    # execute a query and iterate over the result
-    for row in cu.execute("select * from lang"):
-        print(row)
-
-    cx.close()
-
-The sqlite3 module is written by Gerhard Häring <gh@ghaering.de>.
-"""
-
-from sqlite3.dbapi2 import *
-
-
-# bpo-42264: OptimizedUnicode was deprecated in Python 3.10.  It's scheduled
-# for removal in Python 3.12.
-def __getattr__(name):
-    if name == "OptimizedUnicode":
-        import warnings
-        msg = ("""
-            OptimizedUnicode is deprecated and will be removed in Python 3.12.
-            Since Python 3.3 it has simply been an alias for 'str'.
-        """)
-        warnings.warn(msg, DeprecationWarning, stacklevel=2)
-        return str
-    raise AttributeError(f"module 'sqlite3' has no attribute '{name}'")

opt/plesk/python/3/lib/python3.10/sqlite3/dbapi2.py

@@ -1,103 +0,0 @@
-# pysqlite2/dbapi2.py: the DB-API 2.0 interface
-#
-# Copyright (C) 2004-2005 Gerhard Häring <gh@ghaering.de>
-#
-# This file is part of pysqlite.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-#    claim that you wrote the original software. If you use this software
-#    in a product, an acknowledgment in the product documentation would be
-#    appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-#    misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-import datetime
-import time
-import collections.abc
-
-from _sqlite3 import *
-
-paramstyle = "qmark"
-
-threadsafety = 1
-
-apilevel = "2.0"
-
-Date = datetime.date
-
-Time = datetime.time
-
-Timestamp = datetime.datetime
-
-def DateFromTicks(ticks):
-    return Date(*time.localtime(ticks)[:3])
-
-def TimeFromTicks(ticks):
-    return Time(*time.localtime(ticks)[3:6])
-
-def TimestampFromTicks(ticks):
-    return Timestamp(*time.localtime(ticks)[:6])
-
-version_info = tuple([int(x) for x in version.split(".")])
-sqlite_version_info = tuple([int(x) for x in sqlite_version.split(".")])
-
-Binary = memoryview
-collections.abc.Sequence.register(Row)
-
-def register_adapters_and_converters():
-    def adapt_date(val):
-        return val.isoformat()
-
-    def adapt_datetime(val):
-        return val.isoformat(" ")
-
-    def convert_date(val):
-        return datetime.date(*map(int, val.split(b"-")))
-
-    def convert_timestamp(val):
-        datepart, timepart = val.split(b" ")
-        year, month, day = map(int, datepart.split(b"-"))
-        timepart_full = timepart.split(b".")
-        hours, minutes, seconds = map(int, timepart_full[0].split(b":"))
-        if len(timepart_full) == 2:
-            microseconds = int('{:0<6.6}'.format(timepart_full[1].decode()))
-        else:
-            microseconds = 0
-
-        val = datetime.datetime(year, month, day, hours, minutes, seconds, microseconds)
-        return val
-
-
-    register_adapter(datetime.date, adapt_date)
-    register_adapter(datetime.datetime, adapt_datetime)
-    register_converter("date", convert_date)
-    register_converter("timestamp", convert_timestamp)
-
-register_adapters_and_converters()
-
-# bpo-24464: enable_shared_cache was deprecated in Python 3.10.  It's
-# scheduled for removal in Python 3.12.
-def enable_shared_cache(enable):
-    from _sqlite3 import enable_shared_cache as _old_enable_shared_cache
-    import warnings
-    msg = (
-        "enable_shared_cache is deprecated and will be removed in Python 3.12. "
-        "Shared cache is strongly discouraged by the SQLite 3 documentation. "
-        "If shared cache must be used, open the database in URI mode using"
-        "the cache=shared query parameter."
-    )
-    warnings.warn(msg, DeprecationWarning, stacklevel=2)
-    return _old_enable_shared_cache(enable)
-
-# Clean up namespace
-
-del(register_adapters_and_converters)

opt/plesk/python/3/lib/python3.10/sqlite3/dump.py

@@ -1,82 +0,0 @@
-# Mimic the sqlite3 console shell's .dump command
-# Author: Paul Kippes <kippesp@gmail.com>
-
-# Every identifier in sql is quoted based on a comment in sqlite
-# documentation "SQLite adds new keywords from time to time when it
-# takes on new features. So to prevent your code from being broken by
-# future enhancements, you should normally quote any identifier that
-# is an English language word, even if you do not have to."
-
-def _iterdump(connection):
-    """
-    Returns an iterator to the dump of the database in an SQL text format.
-
-    Used to produce an SQL dump of the database.  Useful to save an in-memory
-    database for later restoration.  This function should not be called
-    directly but instead called from the Connection method, iterdump().
-    """
-
-    cu = connection.cursor()
-    yield('BEGIN TRANSACTION;')
-
-    # sqlite_master table contains the SQL CREATE statements for the database.
-    q = """
-        SELECT "name", "type", "sql"
-        FROM "sqlite_master"
-            WHERE "sql" NOT NULL AND
-            "type" == 'table'
-            ORDER BY "name"
-        """
-    schema_res = cu.execute(q)
-    sqlite_sequence = []
-    for table_name, type, sql in schema_res.fetchall():
-        if table_name == 'sqlite_sequence':
-            rows = cu.execute('SELECT * FROM "sqlite_sequence";').fetchall()
-            sqlite_sequence = ['DELETE FROM "sqlite_sequence"']
-            sqlite_sequence += [
-                f'INSERT INTO "sqlite_sequence" VALUES(\'{row[0]}\',{row[1]})'
-                for row in rows
-            ]
-            continue
-        elif table_name == 'sqlite_stat1':
-            yield('ANALYZE "sqlite_master";')
-        elif table_name.startswith('sqlite_'):
-            continue
-        # NOTE: Virtual table support not implemented
-        #elif sql.startswith('CREATE VIRTUAL TABLE'):
-        #    qtable = table_name.replace("'", "''")
-        #    yield("INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"\
-        #        "VALUES('table','{0}','{0}',0,'{1}');".format(
-        #        qtable,
-        #        sql.replace("''")))
-        else:
-            yield('{0};'.format(sql))
-
-        # Build the insert statement for each row of the current table
-        table_name_ident = table_name.replace('"', '""')
-        res = cu.execute('PRAGMA table_info("{0}")'.format(table_name_ident))
-        column_names = [str(table_info[1]) for table_info in res.fetchall()]
-        q = """SELECT 'INSERT INTO "{0}" VALUES({1})' FROM "{0}";""".format(
-            table_name_ident,
-            ",".join("""'||quote("{0}")||'""".format(col.replace('"', '""')) for col in column_names))
-        query_res = cu.execute(q)
-        for row in query_res:
-            yield("{0};".format(row[0]))
-
-    # Now when the type is 'index', 'trigger', or 'view'
-    q = """
-        SELECT "name", "type", "sql"
-        FROM "sqlite_master"
-            WHERE "sql" NOT NULL AND
-            "type" IN ('index', 'trigger', 'view')
-        """
-    schema_res = cu.execute(q)
-    for name, type, sql in schema_res.fetchall():
-        yield('{0};'.format(sql))
-
-    # gh-79009: Yield statements concerning the sqlite_sequence table at the
-    # end of the transaction.
-    for row in sqlite_sequence:
-        yield('{0};'.format(row))
-
-    yield('COMMIT;')

opt/plesk/python/3/lib/python3.10/sqlite3/test/backup.py

@@ -1,167 +0,0 @@
-import sqlite3 as sqlite
-import unittest
-
-
-class BackupTests(unittest.TestCase):
-    def setUp(self):
-        cx = self.cx = sqlite.connect(":memory:")
-        cx.execute('CREATE TABLE foo (key INTEGER)')
-        cx.executemany('INSERT INTO foo (key) VALUES (?)', [(3,), (4,)])
-        cx.commit()
-
-    def tearDown(self):
-        self.cx.close()
-
-    def verify_backup(self, bckcx):
-        result = bckcx.execute("SELECT key FROM foo ORDER BY key").fetchall()
-        self.assertEqual(result[0][0], 3)
-        self.assertEqual(result[1][0], 4)
-
-    def test_bad_target(self):
-        with self.assertRaises(TypeError):
-            self.cx.backup(None)
-        with self.assertRaises(TypeError):
-            self.cx.backup()
-
-    def test_bad_target_filename(self):
-        with self.assertRaises(TypeError):
-            self.cx.backup('some_file_name.db')
-
-    def test_bad_target_same_connection(self):
-        with self.assertRaises(ValueError):
-            self.cx.backup(self.cx)
-
-    def test_bad_target_closed_connection(self):
-        bck = sqlite.connect(':memory:')
-        bck.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            self.cx.backup(bck)
-
-    def test_bad_source_closed_connection(self):
-        bck = sqlite.connect(':memory:')
-        source = sqlite.connect(":memory:")
-        source.close()
-        with self.assertRaises(sqlite.ProgrammingError):
-            source.backup(bck)
-
-    def test_bad_target_in_transaction(self):
-        bck = sqlite.connect(':memory:')
-        bck.execute('CREATE TABLE bar (key INTEGER)')
-        bck.executemany('INSERT INTO bar (key) VALUES (?)', [(3,), (4,)])
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            self.cx.backup(bck)
-        if sqlite.sqlite_version_info < (3, 8, 8):
-            self.assertEqual(str(cm.exception), 'target is in transaction')
-
-    def test_keyword_only_args(self):
-        with self.assertRaises(TypeError):
-            with sqlite.connect(':memory:') as bck:
-                self.cx.backup(bck, 1)
-
-    def test_simple(self):
-        with sqlite.connect(':memory:') as bck:
-            self.cx.backup(bck)
-            self.verify_backup(bck)
-
-    def test_progress(self):
-        journal = []
-
-        def progress(status, remaining, total):
-            journal.append(status)
-
-        with sqlite.connect(':memory:') as bck:
-            self.cx.backup(bck, pages=1, progress=progress)
-            self.verify_backup(bck)
-
-        self.assertEqual(len(journal), 2)
-        self.assertEqual(journal[0], sqlite.SQLITE_OK)
-        self.assertEqual(journal[1], sqlite.SQLITE_DONE)
-
-    def test_progress_all_pages_at_once_1(self):
-        journal = []
-
-        def progress(status, remaining, total):
-            journal.append(remaining)
-
-        with sqlite.connect(':memory:') as bck:
-            self.cx.backup(bck, progress=progress)
-            self.verify_backup(bck)
-
-        self.assertEqual(len(journal), 1)
-        self.assertEqual(journal[0], 0)
-
-    def test_progress_all_pages_at_once_2(self):
-        journal = []
-
-        def progress(status, remaining, total):
-            journal.append(remaining)
-
-        with sqlite.connect(':memory:') as bck:
-            self.cx.backup(bck, pages=-1, progress=progress)
-            self.verify_backup(bck)
-
-        self.assertEqual(len(journal), 1)
-        self.assertEqual(journal[0], 0)
-
-    def test_non_callable_progress(self):
-        with self.assertRaises(TypeError) as cm:
-            with sqlite.connect(':memory:') as bck:
-                self.cx.backup(bck, pages=1, progress='bar')
-        self.assertEqual(str(cm.exception), 'progress argument must be a callable')
-
-    def test_modifying_progress(self):
-        journal = []
-
-        def progress(status, remaining, total):
-            if not journal:
-                self.cx.execute('INSERT INTO foo (key) VALUES (?)', (remaining+1000,))
-                self.cx.commit()
-            journal.append(remaining)
-
-        with sqlite.connect(':memory:') as bck:
-            self.cx.backup(bck, pages=1, progress=progress)
-            self.verify_backup(bck)
-
-            result = bck.execute("SELECT key FROM foo"
-                                 " WHERE key >= 1000"
-                                 " ORDER BY key").fetchall()
-            self.assertEqual(result[0][0], 1001)
-
-        self.assertEqual(len(journal), 3)
-        self.assertEqual(journal[0], 1)
-        self.assertEqual(journal[1], 1)
-        self.assertEqual(journal[2], 0)
-
-    def test_failing_progress(self):
-        def progress(status, remaining, total):
-            raise SystemError('nearly out of space')
-
-        with self.assertRaises(SystemError) as err:
-            with sqlite.connect(':memory:') as bck:
-                self.cx.backup(bck, progress=progress)
-        self.assertEqual(str(err.exception), 'nearly out of space')
-
-    def test_database_source_name(self):
-        with sqlite.connect(':memory:') as bck:
-            self.cx.backup(bck, name='main')
-        with sqlite.connect(':memory:') as bck:
-            self.cx.backup(bck, name='temp')
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            with sqlite.connect(':memory:') as bck:
-                self.cx.backup(bck, name='non-existing')
-        self.assertIn("unknown database", str(cm.exception))
-
-        self.cx.execute("ATTACH DATABASE ':memory:' AS attached_db")
-        self.cx.execute('CREATE TABLE attached_db.foo (key INTEGER)')
-        self.cx.executemany('INSERT INTO attached_db.foo (key) VALUES (?)', [(3,), (4,)])
-        self.cx.commit()
-        with sqlite.connect(':memory:') as bck:
-            self.cx.backup(bck, name='attached_db')
-            self.verify_backup(bck)
-
-
-def suite():
-    return unittest.TestLoader().loadTestsFromTestCase(BackupTests)
-
-if __name__ == "__main__":
-    unittest.main()

opt/plesk/python/3/lib/python3.10/sqlite3/test/dump.py

@@ -1,132 +0,0 @@
-# Author: Paul Kippes <kippesp@gmail.com>
-
-import unittest
-import sqlite3 as sqlite
-
-
-class DumpTests(unittest.TestCase):
-    def setUp(self):
-        self.cx = sqlite.connect(":memory:")
-        self.cu = self.cx.cursor()
-
-    def tearDown(self):
-        self.cx.close()
-
-    def test_table_dump(self):
-        expected_sqls = [
-                """CREATE TABLE "index"("index" blob);"""
-                ,
-                """INSERT INTO "index" VALUES(X'01');"""
-                ,
-                """CREATE TABLE "quoted""table"("quoted""field" text);"""
-                ,
-                """INSERT INTO "quoted""table" VALUES('quoted''value');"""
-                ,
-                "CREATE TABLE t1(id integer primary key, s1 text, " \
-                "t1_i1 integer not null, i2 integer, unique (s1), " \
-                "constraint t1_idx1 unique (i2));"
-                ,
-                "INSERT INTO \"t1\" VALUES(1,'foo',10,20);"
-                ,
-                "INSERT INTO \"t1\" VALUES(2,'foo2',30,30);"
-                ,
-                "CREATE TABLE t2(id integer, t2_i1 integer, " \
-                "t2_i2 integer, primary key (id)," \
-                "foreign key(t2_i1) references t1(t1_i1));"
-                ,
-                "CREATE TRIGGER trigger_1 update of t1_i1 on t1 " \
-                "begin " \
-                "update t2 set t2_i1 = new.t1_i1 where t2_i1 = old.t1_i1; " \
-                "end;"
-                ,
-                "CREATE VIEW v1 as select * from t1 left join t2 " \
-                "using (id);"
-                ]
-        [self.cu.execute(s) for s in expected_sqls]
-        i = self.cx.iterdump()
-        actual_sqls = [s for s in i]
-        expected_sqls = ['BEGIN TRANSACTION;'] + expected_sqls + \
-            ['COMMIT;']
-        [self.assertEqual(expected_sqls[i], actual_sqls[i])
-            for i in range(len(expected_sqls))]
-
-    def test_dump_autoincrement(self):
-        expected = [
-            'CREATE TABLE "t1" (id integer primary key autoincrement);',
-            'INSERT INTO "t1" VALUES(NULL);',
-            'CREATE TABLE "t2" (id integer primary key autoincrement);',
-        ]
-        self.cu.executescript("".join(expected))
-
-        # the NULL value should now be automatically be set to 1
-        expected[1] = expected[1].replace("NULL", "1")
-        expected.insert(0, "BEGIN TRANSACTION;")
-        expected.extend([
-            'DELETE FROM "sqlite_sequence";',
-            'INSERT INTO "sqlite_sequence" VALUES(\'t1\',1);',
-            'COMMIT;',
-        ])
-
-        actual = [stmt for stmt in self.cx.iterdump()]
-        self.assertEqual(expected, actual)
-
-    def test_dump_autoincrement_create_new_db(self):
-        self.cu.execute("BEGIN TRANSACTION")
-        self.cu.execute("CREATE TABLE t1 (id integer primary key autoincrement)")
-        self.cu.execute("CREATE TABLE t2 (id integer primary key autoincrement)")
-        self.cu.executemany("INSERT INTO t1 VALUES(?)", ((None,) for _ in range(9)))
-        self.cu.executemany("INSERT INTO t2 VALUES(?)", ((None,) for _ in range(4)))
-        self.cx.commit()
-
-        cx2 = sqlite.connect(":memory:")
-        query = "".join(self.cx.iterdump())
-        cx2.executescript(query)
-        cu2 = cx2.cursor()
-
-        dataset = (
-            ("t1", 9),
-            ("t2", 4),
-        )
-        for table, seq in dataset:
-            with self.subTest(table=table, seq=seq):
-                res = cu2.execute("""
-                    SELECT "seq" FROM "sqlite_sequence" WHERE "name" == ?
-                """, (table,))
-                rows = res.fetchall()
-                self.assertEqual(rows[0][0], seq)
-
-    def test_unorderable_row(self):
-        # iterdump() should be able to cope with unorderable row types (issue #15545)
-        class UnorderableRow:
-            def __init__(self, cursor, row):
-                self.row = row
-            def __getitem__(self, index):
-                return self.row[index]
-        self.cx.row_factory = UnorderableRow
-        CREATE_ALPHA = """CREATE TABLE "alpha" ("one");"""
-        CREATE_BETA = """CREATE TABLE "beta" ("two");"""
-        expected = [
-            "BEGIN TRANSACTION;",
-            CREATE_ALPHA,
-            CREATE_BETA,
-            "COMMIT;"
-            ]
-        self.cu.execute(CREATE_BETA)
-        self.cu.execute(CREATE_ALPHA)
-        got = list(self.cx.iterdump())
-        self.assertEqual(expected, got)
-
-def suite():
-    tests = [
-        DumpTests,
-    ]
-    return unittest.TestSuite(
-        [unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
-    )
-
-def test():
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
-
-if __name__ == "__main__":
-    test()

opt/plesk/python/3/lib/python3.10/sqlite3/test/factory.py

@@ -1,328 +0,0 @@
-# pysqlite2/test/factory.py: tests for the various factories in pysqlite
-#
-# Copyright (C) 2005-2007 Gerhard Häring <gh@ghaering.de>
-#
-# This file is part of pysqlite.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-#    claim that you wrote the original software. If you use this software
-#    in a product, an acknowledgment in the product documentation would be
-#    appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-#    misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-import unittest
-import sqlite3 as sqlite
-from collections.abc import Sequence
-
-class MyConnection(sqlite.Connection):
-    def __init__(self, *args, **kwargs):
-        sqlite.Connection.__init__(self, *args, **kwargs)
-
-def dict_factory(cursor, row):
-    d = {}
-    for idx, col in enumerate(cursor.description):
-        d[col[0]] = row[idx]
-    return d
-
-class MyCursor(sqlite.Cursor):
-    def __init__(self, *args, **kwargs):
-        sqlite.Cursor.__init__(self, *args, **kwargs)
-        self.row_factory = dict_factory
-
-class ConnectionFactoryTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:", factory=MyConnection)
-
-    def tearDown(self):
-        self.con.close()
-
-    def test_is_instance(self):
-        self.assertIsInstance(self.con, MyConnection)
-
-class CursorFactoryTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-
-    def tearDown(self):
-        self.con.close()
-
-    def test_is_instance(self):
-        cur = self.con.cursor()
-        self.assertIsInstance(cur, sqlite.Cursor)
-        cur = self.con.cursor(MyCursor)
-        self.assertIsInstance(cur, MyCursor)
-        cur = self.con.cursor(factory=lambda con: MyCursor(con))
-        self.assertIsInstance(cur, MyCursor)
-
-    def test_invalid_factory(self):
-        # not a callable at all
-        self.assertRaises(TypeError, self.con.cursor, None)
-        # invalid callable with not exact one argument
-        self.assertRaises(TypeError, self.con.cursor, lambda: None)
-        # invalid callable returning non-cursor
-        self.assertRaises(TypeError, self.con.cursor, lambda con: None)
-
-class RowFactoryTestsBackwardsCompat(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-
-    def test_is_produced_by_factory(self):
-        cur = self.con.cursor(factory=MyCursor)
-        cur.execute("select 4+5 as foo")
-        row = cur.fetchone()
-        self.assertIsInstance(row, dict)
-        cur.close()
-
-    def tearDown(self):
-        self.con.close()
-
-class RowFactoryTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-
-    def test_custom_factory(self):
-        self.con.row_factory = lambda cur, row: list(row)
-        row = self.con.execute("select 1, 2").fetchone()
-        self.assertIsInstance(row, list)
-
-    def test_sqlite_row_index(self):
-        self.con.row_factory = sqlite.Row
-        row = self.con.execute("select 1 as a_1, 2 as b").fetchone()
-        self.assertIsInstance(row, sqlite.Row)
-
-        self.assertEqual(row["a_1"], 1, "by name: wrong result for column 'a_1'")
-        self.assertEqual(row["b"], 2, "by name: wrong result for column 'b'")
-
-        self.assertEqual(row["A_1"], 1, "by name: wrong result for column 'A_1'")
-        self.assertEqual(row["B"], 2, "by name: wrong result for column 'B'")
-
-        self.assertEqual(row[0], 1, "by index: wrong result for column 0")
-        self.assertEqual(row[1], 2, "by index: wrong result for column 1")
-        self.assertEqual(row[-1], 2, "by index: wrong result for column -1")
-        self.assertEqual(row[-2], 1, "by index: wrong result for column -2")
-
-        with self.assertRaises(IndexError):
-            row['c']
-        with self.assertRaises(IndexError):
-            row['a_\x11']
-        with self.assertRaises(IndexError):
-            row['a\x7f1']
-        with self.assertRaises(IndexError):
-            row[2]
-        with self.assertRaises(IndexError):
-            row[-3]
-        with self.assertRaises(IndexError):
-            row[2**1000]
-
-    def test_sqlite_row_index_unicode(self):
-        self.con.row_factory = sqlite.Row
-        row = self.con.execute("select 1 as \xff").fetchone()
-        self.assertEqual(row["\xff"], 1)
-        with self.assertRaises(IndexError):
-            row['\u0178']
-        with self.assertRaises(IndexError):
-            row['\xdf']
-
-    def test_sqlite_row_slice(self):
-        # A sqlite.Row can be sliced like a list.
-        self.con.row_factory = sqlite.Row
-        row = self.con.execute("select 1, 2, 3, 4").fetchone()
-        self.assertEqual(row[0:0], ())
-        self.assertEqual(row[0:1], (1,))
-        self.assertEqual(row[1:3], (2, 3))
-        self.assertEqual(row[3:1], ())
-        # Explicit bounds are optional.
-        self.assertEqual(row[1:], (2, 3, 4))
-        self.assertEqual(row[:3], (1, 2, 3))
-        # Slices can use negative indices.
-        self.assertEqual(row[-2:-1], (3,))
-        self.assertEqual(row[-2:], (3, 4))
-        # Slicing supports steps.
-        self.assertEqual(row[0:4:2], (1, 3))
-        self.assertEqual(row[3:0:-2], (4, 2))
-
-    def test_sqlite_row_iter(self):
-        """Checks if the row object is iterable"""
-        self.con.row_factory = sqlite.Row
-        row = self.con.execute("select 1 as a, 2 as b").fetchone()
-
-        # Is iterable in correct order and produces valid results:
-        items = [col for col in row]
-        self.assertEqual(items, [1, 2])
-
-        # Is iterable the second time:
-        items = [col for col in row]
-        self.assertEqual(items, [1, 2])
-
-    def test_sqlite_row_as_tuple(self):
-        """Checks if the row object can be converted to a tuple"""
-        self.con.row_factory = sqlite.Row
-        row = self.con.execute("select 1 as a, 2 as b").fetchone()
-        t = tuple(row)
-        self.assertEqual(t, (row['a'], row['b']))
-
-    def test_sqlite_row_as_dict(self):
-        """Checks if the row object can be correctly converted to a dictionary"""
-        self.con.row_factory = sqlite.Row
-        row = self.con.execute("select 1 as a, 2 as b").fetchone()
-        d = dict(row)
-        self.assertEqual(d["a"], row["a"])
-        self.assertEqual(d["b"], row["b"])
-
-    def test_sqlite_row_hash_cmp(self):
-        """Checks if the row object compares and hashes correctly"""
-        self.con.row_factory = sqlite.Row
-        row_1 = self.con.execute("select 1 as a, 2 as b").fetchone()
-        row_2 = self.con.execute("select 1 as a, 2 as b").fetchone()
-        row_3 = self.con.execute("select 1 as a, 3 as b").fetchone()
-        row_4 = self.con.execute("select 1 as b, 2 as a").fetchone()
-        row_5 = self.con.execute("select 2 as b, 1 as a").fetchone()
-
-        self.assertTrue(row_1 == row_1)
-        self.assertTrue(row_1 == row_2)
-        self.assertFalse(row_1 == row_3)
-        self.assertFalse(row_1 == row_4)
-        self.assertFalse(row_1 == row_5)
-        self.assertFalse(row_1 == object())
-
-        self.assertFalse(row_1 != row_1)
-        self.assertFalse(row_1 != row_2)
-        self.assertTrue(row_1 != row_3)
-        self.assertTrue(row_1 != row_4)
-        self.assertTrue(row_1 != row_5)
-        self.assertTrue(row_1 != object())
-
-        with self.assertRaises(TypeError):
-            row_1 > row_2
-        with self.assertRaises(TypeError):
-            row_1 < row_2
-        with self.assertRaises(TypeError):
-            row_1 >= row_2
-        with self.assertRaises(TypeError):
-            row_1 <= row_2
-
-        self.assertEqual(hash(row_1), hash(row_2))
-
-    def test_sqlite_row_as_sequence(self):
-        """ Checks if the row object can act like a sequence """
-        self.con.row_factory = sqlite.Row
-        row = self.con.execute("select 1 as a, 2 as b").fetchone()
-
-        as_tuple = tuple(row)
-        self.assertEqual(list(reversed(row)), list(reversed(as_tuple)))
-        self.assertIsInstance(row, Sequence)
-
-    def test_fake_cursor_class(self):
-        # Issue #24257: Incorrect use of PyObject_IsInstance() caused
-        # segmentation fault.
-        # Issue #27861: Also applies for cursor factory.
-        class FakeCursor(str):
-            __class__ = sqlite.Cursor
-        self.con.row_factory = sqlite.Row
-        self.assertRaises(TypeError, self.con.cursor, FakeCursor)
-        self.assertRaises(TypeError, sqlite.Row, FakeCursor(), ())
-
-    def tearDown(self):
-        self.con.close()
-
-class TextFactoryTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-
-    def test_unicode(self):
-        austria = "Österreich"
-        row = self.con.execute("select ?", (austria,)).fetchone()
-        self.assertEqual(type(row[0]), str, "type of row[0] must be unicode")
-
-    def test_string(self):
-        self.con.text_factory = bytes
-        austria = "Österreich"
-        row = self.con.execute("select ?", (austria,)).fetchone()
-        self.assertEqual(type(row[0]), bytes, "type of row[0] must be bytes")
-        self.assertEqual(row[0], austria.encode("utf-8"), "column must equal original data in UTF-8")
-
-    def test_custom(self):
-        self.con.text_factory = lambda x: str(x, "utf-8", "ignore")
-        austria = "Österreich"
-        row = self.con.execute("select ?", (austria,)).fetchone()
-        self.assertEqual(type(row[0]), str, "type of row[0] must be unicode")
-        self.assertTrue(row[0].endswith("reich"), "column must contain original data")
-
-    def test_optimized_unicode(self):
-        # OptimizedUnicode is deprecated as of Python 3.10
-        with self.assertWarns(DeprecationWarning) as cm:
-            self.con.text_factory = sqlite.OptimizedUnicode
-        self.assertIn("factory.py", cm.filename)
-        austria = "Österreich"
-        germany = "Deutchland"
-        a_row = self.con.execute("select ?", (austria,)).fetchone()
-        d_row = self.con.execute("select ?", (germany,)).fetchone()
-        self.assertEqual(type(a_row[0]), str, "type of non-ASCII row must be str")
-        self.assertEqual(type(d_row[0]), str, "type of ASCII-only row must be str")
-
-    def tearDown(self):
-        self.con.close()
-
-class TextFactoryTestsWithEmbeddedZeroBytes(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-        self.con.execute("create table test (value text)")
-        self.con.execute("insert into test (value) values (?)", ("a\x00b",))
-
-    def test_string(self):
-        # text_factory defaults to str
-        row = self.con.execute("select value from test").fetchone()
-        self.assertIs(type(row[0]), str)
-        self.assertEqual(row[0], "a\x00b")
-
-    def test_bytes(self):
-        self.con.text_factory = bytes
-        row = self.con.execute("select value from test").fetchone()
-        self.assertIs(type(row[0]), bytes)
-        self.assertEqual(row[0], b"a\x00b")
-
-    def test_bytearray(self):
-        self.con.text_factory = bytearray
-        row = self.con.execute("select value from test").fetchone()
-        self.assertIs(type(row[0]), bytearray)
-        self.assertEqual(row[0], b"a\x00b")
-
-    def test_custom(self):
-        # A custom factory should receive a bytes argument
-        self.con.text_factory = lambda x: x
-        row = self.con.execute("select value from test").fetchone()
-        self.assertIs(type(row[0]), bytes)
-        self.assertEqual(row[0], b"a\x00b")
-
-    def tearDown(self):
-        self.con.close()
-
-def suite():
-    tests = [
-        ConnectionFactoryTests,
-        CursorFactoryTests,
-        RowFactoryTests,
-        RowFactoryTestsBackwardsCompat,
-        TextFactoryTests,
-        TextFactoryTestsWithEmbeddedZeroBytes,
-    ]
-    return unittest.TestSuite(
-        [unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
-    )
-
-def test():
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
-
-if __name__ == "__main__":
-    test()

opt/plesk/python/3/lib/python3.10/sqlite3/test/hooks.py

@@ -1,306 +0,0 @@
-# pysqlite2/test/hooks.py: tests for various SQLite-specific hooks
-#
-# Copyright (C) 2006-2007 Gerhard Häring <gh@ghaering.de>
-#
-# This file is part of pysqlite.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-#    claim that you wrote the original software. If you use this software
-#    in a product, an acknowledgment in the product documentation would be
-#    appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-#    misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-import contextlib
-import unittest
-import sqlite3 as sqlite
-
-from test.support.os_helper import TESTFN, unlink
-
-
-class CollationTests(unittest.TestCase):
-    def test_create_collation_not_string(self):
-        con = sqlite.connect(":memory:")
-        with self.assertRaises(TypeError):
-            con.create_collation(None, lambda x, y: (x > y) - (x < y))
-
-    def test_create_collation_not_callable(self):
-        con = sqlite.connect(":memory:")
-        with self.assertRaises(TypeError) as cm:
-            con.create_collation("X", 42)
-        self.assertEqual(str(cm.exception), 'parameter must be callable')
-
-    def test_create_collation_not_ascii(self):
-        con = sqlite.connect(":memory:")
-        with self.assertRaises(sqlite.ProgrammingError):
-            con.create_collation("collä", lambda x, y: (x > y) - (x < y))
-
-    def test_create_collation_bad_upper(self):
-        class BadUpperStr(str):
-            def upper(self):
-                return None
-        con = sqlite.connect(":memory:")
-        mycoll = lambda x, y: -((x > y) - (x < y))
-        con.create_collation(BadUpperStr("mycoll"), mycoll)
-        result = con.execute("""
-            select x from (
-            select 'a' as x
-            union
-            select 'b' as x
-            ) order by x collate mycoll
-            """).fetchall()
-        self.assertEqual(result[0][0], 'b')
-        self.assertEqual(result[1][0], 'a')
-
-    def test_collation_is_used(self):
-        def mycoll(x, y):
-            # reverse order
-            return -((x > y) - (x < y))
-
-        con = sqlite.connect(":memory:")
-        con.create_collation("mycoll", mycoll)
-        sql = """
-            select x from (
-            select 'a' as x
-            union
-            select 'b' as x
-            union
-            select 'c' as x
-            ) order by x collate mycoll
-            """
-        result = con.execute(sql).fetchall()
-        self.assertEqual(result, [('c',), ('b',), ('a',)],
-                         msg='the expected order was not returned')
-
-        con.create_collation("mycoll", None)
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            result = con.execute(sql).fetchall()
-        self.assertEqual(str(cm.exception), 'no such collation sequence: mycoll')
-
-    def test_collation_returns_large_integer(self):
-        def mycoll(x, y):
-            # reverse order
-            return -((x > y) - (x < y)) * 2**32
-        con = sqlite.connect(":memory:")
-        con.create_collation("mycoll", mycoll)
-        sql = """
-            select x from (
-            select 'a' as x
-            union
-            select 'b' as x
-            union
-            select 'c' as x
-            ) order by x collate mycoll
-            """
-        result = con.execute(sql).fetchall()
-        self.assertEqual(result, [('c',), ('b',), ('a',)],
-                         msg="the expected order was not returned")
-
-    def test_collation_register_twice(self):
-        """
-        Register two different collation functions under the same name.
-        Verify that the last one is actually used.
-        """
-        con = sqlite.connect(":memory:")
-        con.create_collation("mycoll", lambda x, y: (x > y) - (x < y))
-        con.create_collation("mycoll", lambda x, y: -((x > y) - (x < y)))
-        result = con.execute("""
-            select x from (select 'a' as x union select 'b' as x) order by x collate mycoll
-            """).fetchall()
-        self.assertEqual(result[0][0], 'b')
-        self.assertEqual(result[1][0], 'a')
-
-    def test_deregister_collation(self):
-        """
-        Register a collation, then deregister it. Make sure an error is raised if we try
-        to use it.
-        """
-        con = sqlite.connect(":memory:")
-        con.create_collation("mycoll", lambda x, y: (x > y) - (x < y))
-        con.create_collation("mycoll", None)
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            con.execute("select 'a' as x union select 'b' as x order by x collate mycoll")
-        self.assertEqual(str(cm.exception), 'no such collation sequence: mycoll')
-
-class ProgressTests(unittest.TestCase):
-    def test_progress_handler_used(self):
-        """
-        Test that the progress handler is invoked once it is set.
-        """
-        con = sqlite.connect(":memory:")
-        progress_calls = []
-        def progress():
-            progress_calls.append(None)
-            return 0
-        con.set_progress_handler(progress, 1)
-        con.execute("""
-            create table foo(a, b)
-            """)
-        self.assertTrue(progress_calls)
-
-
-    def test_opcode_count(self):
-        """
-        Test that the opcode argument is respected.
-        """
-        con = sqlite.connect(":memory:")
-        progress_calls = []
-        def progress():
-            progress_calls.append(None)
-            return 0
-        con.set_progress_handler(progress, 1)
-        curs = con.cursor()
-        curs.execute("""
-            create table foo (a, b)
-            """)
-        first_count = len(progress_calls)
-        progress_calls = []
-        con.set_progress_handler(progress, 2)
-        curs.execute("""
-            create table bar (a, b)
-            """)
-        second_count = len(progress_calls)
-        self.assertGreaterEqual(first_count, second_count)
-
-    def test_cancel_operation(self):
-        """
-        Test that returning a non-zero value stops the operation in progress.
-        """
-        con = sqlite.connect(":memory:")
-        def progress():
-            return 1
-        con.set_progress_handler(progress, 1)
-        curs = con.cursor()
-        self.assertRaises(
-            sqlite.OperationalError,
-            curs.execute,
-            "create table bar (a, b)")
-
-    def test_clear_handler(self):
-        """
-        Test that setting the progress handler to None clears the previously set handler.
-        """
-        con = sqlite.connect(":memory:")
-        action = 0
-        def progress():
-            nonlocal action
-            action = 1
-            return 0
-        con.set_progress_handler(progress, 1)
-        con.set_progress_handler(None, 1)
-        con.execute("select 1 union select 2 union select 3").fetchall()
-        self.assertEqual(action, 0, "progress handler was not cleared")
-
-class TraceCallbackTests(unittest.TestCase):
-    @contextlib.contextmanager
-    def check_stmt_trace(self, cx, expected):
-        try:
-            traced = []
-            cx.set_trace_callback(lambda stmt: traced.append(stmt))
-            yield
-        finally:
-            self.assertEqual(traced, expected)
-            cx.set_trace_callback(None)
-
-    def test_trace_callback_used(self):
-        """
-        Test that the trace callback is invoked once it is set.
-        """
-        con = sqlite.connect(":memory:")
-        traced_statements = []
-        def trace(statement):
-            traced_statements.append(statement)
-        con.set_trace_callback(trace)
-        con.execute("create table foo(a, b)")
-        self.assertTrue(traced_statements)
-        self.assertTrue(any("create table foo" in stmt for stmt in traced_statements))
-
-    def test_clear_trace_callback(self):
-        """
-        Test that setting the trace callback to None clears the previously set callback.
-        """
-        con = sqlite.connect(":memory:")
-        traced_statements = []
-        def trace(statement):
-            traced_statements.append(statement)
-        con.set_trace_callback(trace)
-        con.set_trace_callback(None)
-        con.execute("create table foo(a, b)")
-        self.assertFalse(traced_statements, "trace callback was not cleared")
-
-    def test_unicode_content(self):
-        """
-        Test that the statement can contain unicode literals.
-        """
-        unicode_value = '\xf6\xe4\xfc\xd6\xc4\xdc\xdf\u20ac'
-        con = sqlite.connect(":memory:")
-        traced_statements = []
-        def trace(statement):
-            traced_statements.append(statement)
-        con.set_trace_callback(trace)
-        con.execute("create table foo(x)")
-        con.execute("insert into foo(x) values ('%s')" % unicode_value)
-        con.commit()
-        self.assertTrue(any(unicode_value in stmt for stmt in traced_statements),
-                        "Unicode data %s garbled in trace callback: %s"
-                        % (ascii(unicode_value), ', '.join(map(ascii, traced_statements))))
-
-    def test_trace_callback_content(self):
-        # set_trace_callback() shouldn't produce duplicate content (bpo-26187)
-        traced_statements = []
-        def trace(statement):
-            traced_statements.append(statement)
-
-        queries = ["create table foo(x)",
-                   "insert into foo(x) values(1)"]
-        self.addCleanup(unlink, TESTFN)
-        con1 = sqlite.connect(TESTFN, isolation_level=None)
-        con2 = sqlite.connect(TESTFN)
-        con1.set_trace_callback(trace)
-        cur = con1.cursor()
-        cur.execute(queries[0])
-        con2.execute("create table bar(x)")
-        cur.execute(queries[1])
-        self.assertEqual(traced_statements, queries)
-
-    def test_trace_expanded_sql(self):
-        expected = [
-            "create table t(t)",
-            "BEGIN ",
-            "insert into t values(0)",
-            "insert into t values(1)",
-            "insert into t values(2)",
-            "COMMIT",
-        ]
-        cx = sqlite.connect(":memory:")
-        with self.check_stmt_trace(cx, expected):
-            with cx:
-                cx.execute("create table t(t)")
-                cx.executemany("insert into t values(?)", ((v,) for v in range(3)))
-
-
-def suite():
-    tests = [
-        CollationTests,
-        ProgressTests,
-        TraceCallbackTests,
-    ]
-    return unittest.TestSuite(
-        [unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
-    )
-
-def test():
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
-
-if __name__ == "__main__":
-    test()

opt/plesk/python/3/lib/python3.10/sqlite3/test/regression.py

@@ -1,471 +0,0 @@
-# pysqlite2/test/regression.py: pysqlite regression tests
-#
-# Copyright (C) 2006-2010 Gerhard Häring <gh@ghaering.de>
-#
-# This file is part of pysqlite.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-#    claim that you wrote the original software. If you use this software
-#    in a product, an acknowledgment in the product documentation would be
-#    appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-#    misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-import datetime
-import unittest
-import sqlite3 as sqlite
-import weakref
-import functools
-from test import support
-
-from unittest.mock import patch
-
-
-class RegressionTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-
-    def tearDown(self):
-        self.con.close()
-
-    def test_pragma_user_version(self):
-        # This used to crash pysqlite because this pragma command returns NULL for the column name
-        cur = self.con.cursor()
-        cur.execute("pragma user_version")
-
-    def test_pragma_schema_version(self):
-        # This still crashed pysqlite <= 2.2.1
-        con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_COLNAMES)
-        try:
-            cur = self.con.cursor()
-            cur.execute("pragma schema_version")
-        finally:
-            cur.close()
-            con.close()
-
-    def test_statement_reset(self):
-        # pysqlite 2.1.0 to 2.2.0 have the problem that not all statements are
-        # reset before a rollback, but only those that are still in the
-        # statement cache. The others are not accessible from the connection object.
-        con = sqlite.connect(":memory:", cached_statements=5)
-        cursors = [con.cursor() for x in range(5)]
-        cursors[0].execute("create table test(x)")
-        for i in range(10):
-            cursors[0].executemany("insert into test(x) values (?)", [(x,) for x in range(10)])
-
-        for i in range(5):
-            cursors[i].execute(" " * i + "select x from test")
-
-        con.rollback()
-
-    def test_column_name_with_spaces(self):
-        cur = self.con.cursor()
-        cur.execute('select 1 as "foo bar [datetime]"')
-        self.assertEqual(cur.description[0][0], "foo bar [datetime]")
-
-        cur.execute('select 1 as "foo baz"')
-        self.assertEqual(cur.description[0][0], "foo baz")
-
-    def test_statement_finalization_on_close_db(self):
-        # pysqlite versions <= 2.3.3 only finalized statements in the statement
-        # cache when closing the database. statements that were still
-        # referenced in cursors weren't closed and could provoke "
-        # "OperationalError: Unable to close due to unfinalised statements".
-        con = sqlite.connect(":memory:")
-        cursors = []
-        # default statement cache size is 100
-        for i in range(105):
-            cur = con.cursor()
-            cursors.append(cur)
-            cur.execute("select 1 x union select " + str(i))
-        con.close()
-
-    def test_on_conflict_rollback(self):
-        con = sqlite.connect(":memory:")
-        con.execute("create table foo(x, unique(x) on conflict rollback)")
-        con.execute("insert into foo(x) values (1)")
-        try:
-            con.execute("insert into foo(x) values (1)")
-        except sqlite.DatabaseError:
-            pass
-        con.execute("insert into foo(x) values (2)")
-        try:
-            con.commit()
-        except sqlite.OperationalError:
-            self.fail("pysqlite knew nothing about the implicit ROLLBACK")
-
-    def test_workaround_for_buggy_sqlite_transfer_bindings(self):
-        """
-        pysqlite would crash with older SQLite versions unless
-        a workaround is implemented.
-        """
-        self.con.execute("create table foo(bar)")
-        self.con.execute("drop table foo")
-        self.con.execute("create table foo(bar)")
-
-    def test_empty_statement(self):
-        """
-        pysqlite used to segfault with SQLite versions 3.5.x. These return NULL
-        for "no-operation" statements
-        """
-        self.con.execute("")
-
-    def test_type_map_usage(self):
-        """
-        pysqlite until 2.4.1 did not rebuild the row_cast_map when recompiling
-        a statement. This test exhibits the problem.
-        """
-        SELECT = "select * from foo"
-        con = sqlite.connect(":memory:",detect_types=sqlite.PARSE_DECLTYPES)
-        con.execute("create table foo(bar timestamp)")
-        con.execute("insert into foo(bar) values (?)", (datetime.datetime.now(),))
-        con.execute(SELECT).close()
-        con.execute("drop table foo")
-        con.execute("create table foo(bar integer)")
-        con.execute("insert into foo(bar) values (5)")
-        con.execute(SELECT).close()
-
-    def test_bind_mutating_list(self):
-        # Issue41662: Crash when mutate a list of parameters during iteration.
-        class X:
-            def __conform__(self, protocol):
-                parameters.clear()
-                return "..."
-        parameters = [X(), 0]
-        con = sqlite.connect(":memory:",detect_types=sqlite.PARSE_DECLTYPES)
-        con.execute("create table foo(bar X, baz integer)")
-        # Should not crash
-        with self.assertRaises(IndexError):
-            con.execute("insert into foo(bar, baz) values (?, ?)", parameters)
-
-    def test_error_msg_decode_error(self):
-        # When porting the module to Python 3.0, the error message about
-        # decoding errors disappeared. This verifies they're back again.
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            self.con.execute("select 'xxx' || ? || 'yyy' colname",
-                             (bytes(bytearray([250])),)).fetchone()
-        msg = "Could not decode to UTF-8 column 'colname' with text 'xxx"
-        self.assertIn(msg, str(cm.exception))
-
-    def test_register_adapter(self):
-        """
-        See issue 3312.
-        """
-        self.assertRaises(TypeError, sqlite.register_adapter, {}, None)
-
-    def test_set_isolation_level(self):
-        # See issue 27881.
-        class CustomStr(str):
-            def upper(self):
-                return None
-            def __del__(self):
-                con.isolation_level = ""
-
-        con = sqlite.connect(":memory:")
-        con.isolation_level = None
-        for level in "", "DEFERRED", "IMMEDIATE", "EXCLUSIVE":
-            with self.subTest(level=level):
-                con.isolation_level = level
-                con.isolation_level = level.lower()
-                con.isolation_level = level.capitalize()
-                con.isolation_level = CustomStr(level)
-
-        # setting isolation_level failure should not alter previous state
-        con.isolation_level = None
-        con.isolation_level = "DEFERRED"
-        pairs = [
-            (1, TypeError), (b'', TypeError), ("abc", ValueError),
-            ("IMMEDIATE\0EXCLUSIVE", ValueError), ("\xe9", ValueError),
-        ]
-        for value, exc in pairs:
-            with self.subTest(level=value):
-                with self.assertRaises(exc):
-                    con.isolation_level = value
-                self.assertEqual(con.isolation_level, "DEFERRED")
-
-    def test_cursor_constructor_call_check(self):
-        """
-        Verifies that cursor methods check whether base class __init__ was
-        called.
-        """
-        class Cursor(sqlite.Cursor):
-            def __init__(self, con):
-                pass
-
-        con = sqlite.connect(":memory:")
-        cur = Cursor(con)
-        with self.assertRaises(sqlite.ProgrammingError):
-            cur.execute("select 4+5").fetchall()
-        with self.assertRaisesRegex(sqlite.ProgrammingError,
-                                    r'^Base Cursor\.__init__ not called\.$'):
-            cur.close()
-
-    def test_str_subclass(self):
-        """
-        The Python 3.0 port of the module didn't cope with values of subclasses of str.
-        """
-        class MyStr(str): pass
-        self.con.execute("select ?", (MyStr("abc"),))
-
-    def test_connection_constructor_call_check(self):
-        """
-        Verifies that connection methods check whether base class __init__ was
-        called.
-        """
-        class Connection(sqlite.Connection):
-            def __init__(self, name):
-                pass
-
-        con = Connection(":memory:")
-        with self.assertRaises(sqlite.ProgrammingError):
-            cur = con.cursor()
-
-    def test_cursor_registration(self):
-        """
-        Verifies that subclassed cursor classes are correctly registered with
-        the connection object, too.  (fetch-across-rollback problem)
-        """
-        class Connection(sqlite.Connection):
-            def cursor(self):
-                return Cursor(self)
-
-        class Cursor(sqlite.Cursor):
-            def __init__(self, con):
-                sqlite.Cursor.__init__(self, con)
-
-        con = Connection(":memory:")
-        cur = con.cursor()
-        cur.execute("create table foo(x)")
-        cur.executemany("insert into foo(x) values (?)", [(3,), (4,), (5,)])
-        cur.execute("select x from foo")
-        con.rollback()
-        with self.assertRaises(sqlite.InterfaceError):
-            cur.fetchall()
-
-    def test_auto_commit(self):
-        """
-        Verifies that creating a connection in autocommit mode works.
-        2.5.3 introduced a regression so that these could no longer
-        be created.
-        """
-        con = sqlite.connect(":memory:", isolation_level=None)
-
-    def test_pragma_autocommit(self):
-        """
-        Verifies that running a PRAGMA statement that does an autocommit does
-        work. This did not work in 2.5.3/2.5.4.
-        """
-        cur = self.con.cursor()
-        cur.execute("create table foo(bar)")
-        cur.execute("insert into foo(bar) values (5)")
-
-        cur.execute("pragma page_size")
-        row = cur.fetchone()
-
-    def test_connection_call(self):
-        """
-        Call a connection with a non-string SQL request: check error handling
-        of the statement constructor.
-        """
-        self.assertRaises(TypeError, self.con, 1)
-
-    def test_collation(self):
-        def collation_cb(a, b):
-            return 1
-        self.assertRaises(sqlite.ProgrammingError, self.con.create_collation,
-            # Lone surrogate cannot be encoded to the default encoding (utf8)
-            "\uDC80", collation_cb)
-
-    def test_recursive_cursor_use(self):
-        """
-        http://bugs.python.org/issue10811
-
-        Recursively using a cursor, such as when reusing it from a generator led to segfaults.
-        Now we catch recursive cursor usage and raise a ProgrammingError.
-        """
-        con = sqlite.connect(":memory:")
-
-        cur = con.cursor()
-        cur.execute("create table a (bar)")
-        cur.execute("create table b (baz)")
-
-        def foo():
-            cur.execute("insert into a (bar) values (?)", (1,))
-            yield 1
-
-        with self.assertRaises(sqlite.ProgrammingError):
-            cur.executemany("insert into b (baz) values (?)",
-                            ((i,) for i in foo()))
-
-    def test_convert_timestamp_microsecond_padding(self):
-        """
-        http://bugs.python.org/issue14720
-
-        The microsecond parsing of convert_timestamp() should pad with zeros,
-        since the microsecond string "456" actually represents "456000".
-        """
-
-        con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES)
-        cur = con.cursor()
-        cur.execute("CREATE TABLE t (x TIMESTAMP)")
-
-        # Microseconds should be 456000
-        cur.execute("INSERT INTO t (x) VALUES ('2012-04-04 15:06:00.456')")
-
-        # Microseconds should be truncated to 123456
-        cur.execute("INSERT INTO t (x) VALUES ('2012-04-04 15:06:00.123456789')")
-
-        cur.execute("SELECT * FROM t")
-        values = [x[0] for x in cur.fetchall()]
-
-        self.assertEqual(values, [
-            datetime.datetime(2012, 4, 4, 15, 6, 0, 456000),
-            datetime.datetime(2012, 4, 4, 15, 6, 0, 123456),
-        ])
-
-    def test_invalid_isolation_level_type(self):
-        # isolation level is a string, not an integer
-        self.assertRaises(TypeError,
-                          sqlite.connect, ":memory:", isolation_level=123)
-
-
-    def test_null_character(self):
-        # Issue #21147
-        con = sqlite.connect(":memory:")
-        self.assertRaises(ValueError, con, "\0select 1")
-        self.assertRaises(ValueError, con, "select 1\0")
-        cur = con.cursor()
-        self.assertRaises(ValueError, cur.execute, " \0select 2")
-        self.assertRaises(ValueError, cur.execute, "select 2\0")
-
-    def test_commit_cursor_reset(self):
-        """
-        Connection.commit() did reset cursors, which made sqlite3
-        to return rows multiple times when fetched from cursors
-        after commit. See issues 10513 and 23129 for details.
-        """
-        con = sqlite.connect(":memory:")
-        con.executescript("""
-        create table t(c);
-        create table t2(c);
-        insert into t values(0);
-        insert into t values(1);
-        insert into t values(2);
-        """)
-
-        self.assertEqual(con.isolation_level, "")
-
-        counter = 0
-        for i, row in enumerate(con.execute("select c from t")):
-            with self.subTest(i=i, row=row):
-                con.execute("insert into t2(c) values (?)", (i,))
-                con.commit()
-                if counter == 0:
-                    self.assertEqual(row[0], 0)
-                elif counter == 1:
-                    self.assertEqual(row[0], 1)
-                elif counter == 2:
-                    self.assertEqual(row[0], 2)
-                counter += 1
-        self.assertEqual(counter, 3, "should have returned exactly three rows")
-
-    def test_bpo31770(self):
-        """
-        The interpreter shouldn't crash in case Cursor.__init__() is called
-        more than once.
-        """
-        def callback(*args):
-            pass
-        con = sqlite.connect(":memory:")
-        cur = sqlite.Cursor(con)
-        ref = weakref.ref(cur, callback)
-        cur.__init__(con)
-        del cur
-        # The interpreter shouldn't crash when ref is collected.
-        del ref
-        support.gc_collect()
-
-    def test_del_isolation_level_segfault(self):
-        with self.assertRaises(AttributeError):
-            del self.con.isolation_level
-
-    def test_bpo37347(self):
-        class Printer:
-            def log(self, *args):
-                return sqlite.SQLITE_OK
-
-        for method in [self.con.set_trace_callback,
-                       functools.partial(self.con.set_progress_handler, n=1),
-                       self.con.set_authorizer]:
-            printer_instance = Printer()
-            method(printer_instance.log)
-            method(printer_instance.log)
-            self.con.execute("select 1")  # trigger seg fault
-            method(None)
-
-    def test_return_empty_bytestring(self):
-        cur = self.con.execute("select X''")
-        val = cur.fetchone()[0]
-        self.assertEqual(val, b'')
-
-
-class RecursiveUseOfCursors(unittest.TestCase):
-    # GH-80254: sqlite3 should not segfault for recursive use of cursors.
-    msg = "Recursive use of cursors not allowed"
-
-    def setUp(self):
-        self.con = sqlite.connect(":memory:",
-                                  detect_types=sqlite.PARSE_COLNAMES)
-        self.cur = self.con.cursor()
-        self.cur.execute("create table test(x foo)")
-        self.cur.executemany("insert into test(x) values (?)",
-                             [("foo",), ("bar",)])
-
-    def tearDown(self):
-        self.cur.close()
-        self.con.close()
-
-    def test_recursive_cursor_init(self):
-        conv = lambda x: self.cur.__init__(self.con)
-        with patch.dict(sqlite.converters, {"INIT": conv}):
-            with self.assertRaisesRegex(sqlite.ProgrammingError, self.msg):
-                self.cur.execute(f'select x as "x [INIT]", x from test')
-
-    def test_recursive_cursor_close(self):
-        conv = lambda x: self.cur.close()
-        with patch.dict(sqlite.converters, {"CLOSE": conv}):
-            with self.assertRaisesRegex(sqlite.ProgrammingError, self.msg):
-                self.cur.execute(f'select x as "x [CLOSE]", x from test')
-
-    def test_recursive_cursor_fetch(self):
-        conv = lambda x, l=[]: self.cur.fetchone() if l else l.append(None)
-        with patch.dict(sqlite.converters, {"ITER": conv}):
-            self.cur.execute(f'select x as "x [ITER]", x from test')
-            with self.assertRaisesRegex(sqlite.ProgrammingError, self.msg):
-                self.cur.fetchall()
-
-
-def suite():
-    tests = [
-        RegressionTests,
-        RecursiveUseOfCursors,
-    ]
-    return unittest.TestSuite(
-        [unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
-    )
-
-def test():
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
-
-if __name__ == "__main__":
-    test()

opt/plesk/python/3/lib/python3.10/sqlite3/test/transactions.py

@@ -1,211 +0,0 @@
-# pysqlite2/test/transactions.py: tests transactions
-#
-# Copyright (C) 2005-2007 Gerhard Häring <gh@ghaering.de>
-#
-# This file is part of pysqlite.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-#    claim that you wrote the original software. If you use this software
-#    in a product, an acknowledgment in the product documentation would be
-#    appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-#    misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-import os, unittest
-import sqlite3 as sqlite
-
-from test.support import LOOPBACK_TIMEOUT
-from test.support.os_helper import TESTFN, unlink
-
-
-TIMEOUT = LOOPBACK_TIMEOUT / 10
-
-
-class TransactionTests(unittest.TestCase):
-    def setUp(self):
-        self.con1 = sqlite.connect(TESTFN, timeout=TIMEOUT)
-        self.cur1 = self.con1.cursor()
-
-        self.con2 = sqlite.connect(TESTFN, timeout=TIMEOUT)
-        self.cur2 = self.con2.cursor()
-
-    def tearDown(self):
-        try:
-            self.cur1.close()
-            self.con1.close()
-
-            self.cur2.close()
-            self.con2.close()
-
-        finally:
-            unlink(TESTFN)
-
-    def test_dml_does_not_auto_commit_before(self):
-        self.cur1.execute("create table test(i)")
-        self.cur1.execute("insert into test(i) values (5)")
-        self.cur1.execute("create table test2(j)")
-        self.cur2.execute("select i from test")
-        res = self.cur2.fetchall()
-        self.assertEqual(len(res), 0)
-
-    def test_insert_starts_transaction(self):
-        self.cur1.execute("create table test(i)")
-        self.cur1.execute("insert into test(i) values (5)")
-        self.cur2.execute("select i from test")
-        res = self.cur2.fetchall()
-        self.assertEqual(len(res), 0)
-
-    def test_update_starts_transaction(self):
-        self.cur1.execute("create table test(i)")
-        self.cur1.execute("insert into test(i) values (5)")
-        self.con1.commit()
-        self.cur1.execute("update test set i=6")
-        self.cur2.execute("select i from test")
-        res = self.cur2.fetchone()[0]
-        self.assertEqual(res, 5)
-
-    def test_delete_starts_transaction(self):
-        self.cur1.execute("create table test(i)")
-        self.cur1.execute("insert into test(i) values (5)")
-        self.con1.commit()
-        self.cur1.execute("delete from test")
-        self.cur2.execute("select i from test")
-        res = self.cur2.fetchall()
-        self.assertEqual(len(res), 1)
-
-    def test_replace_starts_transaction(self):
-        self.cur1.execute("create table test(i)")
-        self.cur1.execute("insert into test(i) values (5)")
-        self.con1.commit()
-        self.cur1.execute("replace into test(i) values (6)")
-        self.cur2.execute("select i from test")
-        res = self.cur2.fetchall()
-        self.assertEqual(len(res), 1)
-        self.assertEqual(res[0][0], 5)
-
-    def test_toggle_auto_commit(self):
-        self.cur1.execute("create table test(i)")
-        self.cur1.execute("insert into test(i) values (5)")
-        self.con1.isolation_level = None
-        self.assertEqual(self.con1.isolation_level, None)
-        self.cur2.execute("select i from test")
-        res = self.cur2.fetchall()
-        self.assertEqual(len(res), 1)
-
-        self.con1.isolation_level = "DEFERRED"
-        self.assertEqual(self.con1.isolation_level , "DEFERRED")
-        self.cur1.execute("insert into test(i) values (5)")
-        self.cur2.execute("select i from test")
-        res = self.cur2.fetchall()
-        self.assertEqual(len(res), 1)
-
-    def test_raise_timeout(self):
-        self.cur1.execute("create table test(i)")
-        self.cur1.execute("insert into test(i) values (5)")
-        with self.assertRaises(sqlite.OperationalError):
-            self.cur2.execute("insert into test(i) values (5)")
-
-    def test_locking(self):
-        """
-        This tests the improved concurrency with pysqlite 2.3.4. You needed
-        to roll back con2 before you could commit con1.
-        """
-        self.cur1.execute("create table test(i)")
-        self.cur1.execute("insert into test(i) values (5)")
-        with self.assertRaises(sqlite.OperationalError):
-            self.cur2.execute("insert into test(i) values (5)")
-        # NO self.con2.rollback() HERE!!!
-        self.con1.commit()
-
-    def test_rollback_cursor_consistency(self):
-        """
-        Checks if cursors on the connection are set into a "reset" state
-        when a rollback is done on the connection.
-        """
-        con = sqlite.connect(":memory:")
-        cur = con.cursor()
-        cur.execute("create table test(x)")
-        cur.execute("insert into test(x) values (5)")
-        cur.execute("select 1 union select 2 union select 3")
-
-        con.rollback()
-        with self.assertRaises(sqlite.InterfaceError):
-            cur.fetchall()
-
-class SpecialCommandTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-        self.cur = self.con.cursor()
-
-    def test_drop_table(self):
-        self.cur.execute("create table test(i)")
-        self.cur.execute("insert into test(i) values (5)")
-        self.cur.execute("drop table test")
-
-    def test_pragma(self):
-        self.cur.execute("create table test(i)")
-        self.cur.execute("insert into test(i) values (5)")
-        self.cur.execute("pragma count_changes=1")
-
-    def tearDown(self):
-        self.cur.close()
-        self.con.close()
-
-class TransactionalDDL(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-
-    def test_ddl_does_not_autostart_transaction(self):
-        # For backwards compatibility reasons, DDL statements should not
-        # implicitly start a transaction.
-        self.con.execute("create table test(i)")
-        self.con.rollback()
-        result = self.con.execute("select * from test").fetchall()
-        self.assertEqual(result, [])
-
-    def test_immediate_transactional_ddl(self):
-        # You can achieve transactional DDL by issuing a BEGIN
-        # statement manually.
-        self.con.execute("begin immediate")
-        self.con.execute("create table test(i)")
-        self.con.rollback()
-        with self.assertRaises(sqlite.OperationalError):
-            self.con.execute("select * from test")
-
-    def test_transactional_ddl(self):
-        # You can achieve transactional DDL by issuing a BEGIN
-        # statement manually.
-        self.con.execute("begin")
-        self.con.execute("create table test(i)")
-        self.con.rollback()
-        with self.assertRaises(sqlite.OperationalError):
-            self.con.execute("select * from test")
-
-    def tearDown(self):
-        self.con.close()
-
-def suite():
-    tests = [
-        SpecialCommandTests,
-        TransactionTests,
-        TransactionalDDL,
-    ]
-    return unittest.TestSuite(
-        [unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
-    )
-
-def test():
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
-
-if __name__ == "__main__":
-    test()

opt/plesk/python/3/lib/python3.10/sqlite3/test/types.py

@@ -1,467 +0,0 @@
-# pysqlite2/test/types.py: tests for type conversion and detection
-#
-# Copyright (C) 2005 Gerhard Häring <gh@ghaering.de>
-#
-# This file is part of pysqlite.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-#    claim that you wrote the original software. If you use this software
-#    in a product, an acknowledgment in the product documentation would be
-#    appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-#    misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-import datetime
-import unittest
-import sqlite3 as sqlite
-try:
-    import zlib
-except ImportError:
-    zlib = None
-
-
-class SqliteTypeTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-        self.cur = self.con.cursor()
-        self.cur.execute("create table test(i integer, s varchar, f number, b blob)")
-
-    def tearDown(self):
-        self.cur.close()
-        self.con.close()
-
-    def test_string(self):
-        self.cur.execute("insert into test(s) values (?)", ("Österreich",))
-        self.cur.execute("select s from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], "Österreich")
-
-    def test_small_int(self):
-        self.cur.execute("insert into test(i) values (?)", (42,))
-        self.cur.execute("select i from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], 42)
-
-    def test_large_int(self):
-        num = 2**40
-        self.cur.execute("insert into test(i) values (?)", (num,))
-        self.cur.execute("select i from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], num)
-
-    def test_float(self):
-        val = 3.14
-        self.cur.execute("insert into test(f) values (?)", (val,))
-        self.cur.execute("select f from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], val)
-
-    def test_blob(self):
-        sample = b"Guglhupf"
-        val = memoryview(sample)
-        self.cur.execute("insert into test(b) values (?)", (val,))
-        self.cur.execute("select b from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], sample)
-
-    def test_unicode_execute(self):
-        self.cur.execute("select 'Österreich'")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], "Österreich")
-
-class DeclTypesTests(unittest.TestCase):
-    class Foo:
-        def __init__(self, _val):
-            if isinstance(_val, bytes):
-                # sqlite3 always calls __init__ with a bytes created from a
-                # UTF-8 string when __conform__ was used to store the object.
-                _val = _val.decode('utf-8')
-            self.val = _val
-
-        def __eq__(self, other):
-            if not isinstance(other, DeclTypesTests.Foo):
-                return NotImplemented
-            return self.val == other.val
-
-        def __conform__(self, protocol):
-            if protocol is sqlite.PrepareProtocol:
-                return self.val
-            else:
-                return None
-
-        def __str__(self):
-            return "<%s>" % self.val
-
-    class BadConform:
-        def __init__(self, exc):
-            self.exc = exc
-        def __conform__(self, protocol):
-            raise self.exc
-
-    def setUp(self):
-        self.con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES)
-        self.cur = self.con.cursor()
-        self.cur.execute("""
-            create table test(
-                i int,
-                s str,
-                f float,
-                b bool,
-                u unicode,
-                foo foo,
-                bin blob,
-                n1 number,
-                n2 number(5),
-                bad bad,
-                cbin cblob)
-        """)
-
-        # override float, make them always return the same number
-        sqlite.converters["FLOAT"] = lambda x: 47.2
-
-        # and implement two custom ones
-        sqlite.converters["BOOL"] = lambda x: bool(int(x))
-        sqlite.converters["FOO"] = DeclTypesTests.Foo
-        sqlite.converters["BAD"] = DeclTypesTests.BadConform
-        sqlite.converters["WRONG"] = lambda x: "WRONG"
-        sqlite.converters["NUMBER"] = float
-        sqlite.converters["CBLOB"] = lambda x: b"blobish"
-
-    def tearDown(self):
-        del sqlite.converters["FLOAT"]
-        del sqlite.converters["BOOL"]
-        del sqlite.converters["FOO"]
-        del sqlite.converters["BAD"]
-        del sqlite.converters["WRONG"]
-        del sqlite.converters["NUMBER"]
-        del sqlite.converters["CBLOB"]
-        self.cur.close()
-        self.con.close()
-
-    def test_string(self):
-        # default
-        self.cur.execute("insert into test(s) values (?)", ("foo",))
-        self.cur.execute('select s as "s [WRONG]" from test')
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], "foo")
-
-    def test_small_int(self):
-        # default
-        self.cur.execute("insert into test(i) values (?)", (42,))
-        self.cur.execute("select i from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], 42)
-
-    def test_large_int(self):
-        # default
-        num = 2**40
-        self.cur.execute("insert into test(i) values (?)", (num,))
-        self.cur.execute("select i from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], num)
-
-    def test_float(self):
-        # custom
-        val = 3.14
-        self.cur.execute("insert into test(f) values (?)", (val,))
-        self.cur.execute("select f from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], 47.2)
-
-    def test_bool(self):
-        # custom
-        self.cur.execute("insert into test(b) values (?)", (False,))
-        self.cur.execute("select b from test")
-        row = self.cur.fetchone()
-        self.assertIs(row[0], False)
-
-        self.cur.execute("delete from test")
-        self.cur.execute("insert into test(b) values (?)", (True,))
-        self.cur.execute("select b from test")
-        row = self.cur.fetchone()
-        self.assertIs(row[0], True)
-
-    def test_unicode(self):
-        # default
-        val = "\xd6sterreich"
-        self.cur.execute("insert into test(u) values (?)", (val,))
-        self.cur.execute("select u from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], val)
-
-    def test_foo(self):
-        val = DeclTypesTests.Foo("bla")
-        self.cur.execute("insert into test(foo) values (?)", (val,))
-        self.cur.execute("select foo from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], val)
-
-    def test_error_in_conform(self):
-        val = DeclTypesTests.BadConform(TypeError)
-        with self.assertRaises(sqlite.InterfaceError):
-            self.cur.execute("insert into test(bad) values (?)", (val,))
-        with self.assertRaises(sqlite.InterfaceError):
-            self.cur.execute("insert into test(bad) values (:val)", {"val": val})
-
-        val = DeclTypesTests.BadConform(KeyboardInterrupt)
-        with self.assertRaises(KeyboardInterrupt):
-            self.cur.execute("insert into test(bad) values (?)", (val,))
-        with self.assertRaises(KeyboardInterrupt):
-            self.cur.execute("insert into test(bad) values (:val)", {"val": val})
-
-    def test_unsupported_seq(self):
-        class Bar: pass
-        val = Bar()
-        with self.assertRaises(sqlite.InterfaceError):
-            self.cur.execute("insert into test(f) values (?)", (val,))
-
-    def test_unsupported_dict(self):
-        class Bar: pass
-        val = Bar()
-        with self.assertRaises(sqlite.InterfaceError):
-            self.cur.execute("insert into test(f) values (:val)", {"val": val})
-
-    def test_blob(self):
-        # default
-        sample = b"Guglhupf"
-        val = memoryview(sample)
-        self.cur.execute("insert into test(bin) values (?)", (val,))
-        self.cur.execute("select bin from test")
-        row = self.cur.fetchone()
-        self.assertEqual(row[0], sample)
-
-    def test_number1(self):
-        self.cur.execute("insert into test(n1) values (5)")
-        value = self.cur.execute("select n1 from test").fetchone()[0]
-        # if the converter is not used, it's an int instead of a float
-        self.assertEqual(type(value), float)
-
-    def test_number2(self):
-        """Checks whether converter names are cut off at '(' characters"""
-        self.cur.execute("insert into test(n2) values (5)")
-        value = self.cur.execute("select n2 from test").fetchone()[0]
-        # if the converter is not used, it's an int instead of a float
-        self.assertEqual(type(value), float)
-
-    def test_convert_zero_sized_blob(self):
-        self.con.execute("insert into test(cbin) values (?)", (b"",))
-        cur = self.con.execute("select cbin from test")
-        # Zero-sized blobs with converters returns None.  This differs from
-        # blobs without a converter, where b"" is returned.
-        self.assertIsNone(cur.fetchone()[0])
-
-
-class ColNamesTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_COLNAMES)
-        self.cur = self.con.cursor()
-        self.cur.execute("create table test(x foo)")
-
-        sqlite.converters["FOO"] = lambda x: "[%s]" % x.decode("ascii")
-        sqlite.converters["BAR"] = lambda x: "<%s>" % x.decode("ascii")
-        sqlite.converters["EXC"] = lambda x: 5/0
-        sqlite.converters["B1B1"] = lambda x: "MARKER"
-
-    def tearDown(self):
-        del sqlite.converters["FOO"]
-        del sqlite.converters["BAR"]
-        del sqlite.converters["EXC"]
-        del sqlite.converters["B1B1"]
-        self.cur.close()
-        self.con.close()
-
-    def test_decl_type_not_used(self):
-        """
-        Assures that the declared type is not used when PARSE_DECLTYPES
-        is not set.
-        """
-        self.cur.execute("insert into test(x) values (?)", ("xxx",))
-        self.cur.execute("select x from test")
-        val = self.cur.fetchone()[0]
-        self.assertEqual(val, "xxx")
-
-    def test_none(self):
-        self.cur.execute("insert into test(x) values (?)", (None,))
-        self.cur.execute("select x from test")
-        val = self.cur.fetchone()[0]
-        self.assertEqual(val, None)
-
-    def test_col_name(self):
-        self.cur.execute("insert into test(x) values (?)", ("xxx",))
-        self.cur.execute('select x as "x y [bar]" from test')
-        val = self.cur.fetchone()[0]
-        self.assertEqual(val, "<xxx>")
-
-        # Check if the stripping of colnames works. Everything after the first
-        # '[' (and the preceeding space) should be stripped.
-        self.assertEqual(self.cur.description[0][0], "x y")
-
-    def test_case_in_converter_name(self):
-        self.cur.execute("select 'other' as \"x [b1b1]\"")
-        val = self.cur.fetchone()[0]
-        self.assertEqual(val, "MARKER")
-
-    def test_cursor_description_no_row(self):
-        """
-        cursor.description should at least provide the column name(s), even if
-        no row returned.
-        """
-        self.cur.execute("select * from test where 0 = 1")
-        self.assertEqual(self.cur.description[0][0], "x")
-
-    def test_cursor_description_insert(self):
-        self.cur.execute("insert into test values (1)")
-        self.assertIsNone(self.cur.description)
-
-
-@unittest.skipIf(sqlite.sqlite_version_info < (3, 8, 3), "CTEs not supported")
-class CommonTableExpressionTests(unittest.TestCase):
-
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-        self.cur = self.con.cursor()
-        self.cur.execute("create table test(x foo)")
-
-    def tearDown(self):
-        self.cur.close()
-        self.con.close()
-
-    def test_cursor_description_cte_simple(self):
-        self.cur.execute("with one as (select 1) select * from one")
-        self.assertIsNotNone(self.cur.description)
-        self.assertEqual(self.cur.description[0][0], "1")
-
-    def test_cursor_description_cte_multiple_columns(self):
-        self.cur.execute("insert into test values(1)")
-        self.cur.execute("insert into test values(2)")
-        self.cur.execute("with testCTE as (select * from test) select * from testCTE")
-        self.assertIsNotNone(self.cur.description)
-        self.assertEqual(self.cur.description[0][0], "x")
-
-    def test_cursor_description_cte(self):
-        self.cur.execute("insert into test values (1)")
-        self.cur.execute("with bar as (select * from test) select * from test where x = 1")
-        self.assertIsNotNone(self.cur.description)
-        self.assertEqual(self.cur.description[0][0], "x")
-        self.cur.execute("with bar as (select * from test) select * from test where x = 2")
-        self.assertIsNotNone(self.cur.description)
-        self.assertEqual(self.cur.description[0][0], "x")
-
-
-class ObjectAdaptationTests(unittest.TestCase):
-    def cast(obj):
-        return float(obj)
-    cast = staticmethod(cast)
-
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-        try:
-            del sqlite.adapters[int]
-        except:
-            pass
-        sqlite.register_adapter(int, ObjectAdaptationTests.cast)
-        self.cur = self.con.cursor()
-
-    def tearDown(self):
-        del sqlite.adapters[(int, sqlite.PrepareProtocol)]
-        self.cur.close()
-        self.con.close()
-
-    def test_caster_is_used(self):
-        self.cur.execute("select ?", (4,))
-        val = self.cur.fetchone()[0]
-        self.assertEqual(type(val), float)
-
-@unittest.skipUnless(zlib, "requires zlib")
-class BinaryConverterTests(unittest.TestCase):
-    def convert(s):
-        return zlib.decompress(s)
-    convert = staticmethod(convert)
-
-    def setUp(self):
-        self.con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_COLNAMES)
-        sqlite.register_converter("bin", BinaryConverterTests.convert)
-
-    def tearDown(self):
-        self.con.close()
-
-    def test_binary_input_for_converter(self):
-        testdata = b"abcdefg" * 10
-        result = self.con.execute('select ? as "x [bin]"', (memoryview(zlib.compress(testdata)),)).fetchone()[0]
-        self.assertEqual(testdata, result)
-
-class DateTimeTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_DECLTYPES)
-        self.cur = self.con.cursor()
-        self.cur.execute("create table test(d date, ts timestamp)")
-
-    def tearDown(self):
-        self.cur.close()
-        self.con.close()
-
-    def test_sqlite_date(self):
-        d = sqlite.Date(2004, 2, 14)
-        self.cur.execute("insert into test(d) values (?)", (d,))
-        self.cur.execute("select d from test")
-        d2 = self.cur.fetchone()[0]
-        self.assertEqual(d, d2)
-
-    def test_sqlite_timestamp(self):
-        ts = sqlite.Timestamp(2004, 2, 14, 7, 15, 0)
-        self.cur.execute("insert into test(ts) values (?)", (ts,))
-        self.cur.execute("select ts from test")
-        ts2 = self.cur.fetchone()[0]
-        self.assertEqual(ts, ts2)
-
-    def test_sql_timestamp(self):
-        now = datetime.datetime.utcnow()
-        self.cur.execute("insert into test(ts) values (current_timestamp)")
-        self.cur.execute("select ts from test")
-        ts = self.cur.fetchone()[0]
-        self.assertEqual(type(ts), datetime.datetime)
-        self.assertEqual(ts.year, now.year)
-
-    def test_date_time_sub_seconds(self):
-        ts = sqlite.Timestamp(2004, 2, 14, 7, 15, 0, 500000)
-        self.cur.execute("insert into test(ts) values (?)", (ts,))
-        self.cur.execute("select ts from test")
-        ts2 = self.cur.fetchone()[0]
-        self.assertEqual(ts, ts2)
-
-    def test_date_time_sub_seconds_floating_point(self):
-        ts = sqlite.Timestamp(2004, 2, 14, 7, 15, 0, 510241)
-        self.cur.execute("insert into test(ts) values (?)", (ts,))
-        self.cur.execute("select ts from test")
-        ts2 = self.cur.fetchone()[0]
-        self.assertEqual(ts, ts2)
-
-def suite():
-    tests = [
-        BinaryConverterTests,
-        ColNamesTests,
-        CommonTableExpressionTests,
-        DateTimeTests,
-        DeclTypesTests,
-        ObjectAdaptationTests,
-        SqliteTypeTests,
-    ]
-    return unittest.TestSuite(
-        [unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
-    )
-
-def test():
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
-
-if __name__ == "__main__":
-    test()

opt/plesk/python/3/lib/python3.10/sqlite3/test/userfunctions.py

@@ -1,572 +0,0 @@
-# pysqlite2/test/userfunctions.py: tests for user-defined functions and
-#                                  aggregates.
-#
-# Copyright (C) 2005-2007 Gerhard Häring <gh@ghaering.de>
-#
-# This file is part of pysqlite.
-#
-# This software is provided 'as-is', without any express or implied
-# warranty.  In no event will the authors be held liable for any damages
-# arising from the use of this software.
-#
-# Permission is granted to anyone to use this software for any purpose,
-# including commercial applications, and to alter it and redistribute it
-# freely, subject to the following restrictions:
-#
-# 1. The origin of this software must not be misrepresented; you must not
-#    claim that you wrote the original software. If you use this software
-#    in a product, an acknowledgment in the product documentation would be
-#    appreciated but is not required.
-# 2. Altered source versions must be plainly marked as such, and must not be
-#    misrepresented as being the original software.
-# 3. This notice may not be removed or altered from any source distribution.
-
-import unittest
-import unittest.mock
-import sqlite3 as sqlite
-
-from test.support import gc_collect
-
-
-def func_returntext():
-    return "foo"
-def func_returntextwithnull():
-    return "1\x002"
-def func_returnunicode():
-    return "bar"
-def func_returnint():
-    return 42
-def func_returnfloat():
-    return 3.14
-def func_returnnull():
-    return None
-def func_returnblob():
-    return b"blob"
-def func_returnlonglong():
-    return 1<<31
-def func_raiseexception():
-    5/0
-
-class AggrNoStep:
-    def __init__(self):
-        pass
-
-    def finalize(self):
-        return 1
-
-class AggrNoFinalize:
-    def __init__(self):
-        pass
-
-    def step(self, x):
-        pass
-
-class AggrExceptionInInit:
-    def __init__(self):
-        5/0
-
-    def step(self, x):
-        pass
-
-    def finalize(self):
-        pass
-
-class AggrExceptionInStep:
-    def __init__(self):
-        pass
-
-    def step(self, x):
-        5/0
-
-    def finalize(self):
-        return 42
-
-class AggrExceptionInFinalize:
-    def __init__(self):
-        pass
-
-    def step(self, x):
-        pass
-
-    def finalize(self):
-        5/0
-
-class AggrCheckType:
-    def __init__(self):
-        self.val = None
-
-    def step(self, whichType, val):
-        theType = {"str": str, "int": int, "float": float, "None": type(None),
-                   "blob": bytes}
-        self.val = int(theType[whichType] is type(val))
-
-    def finalize(self):
-        return self.val
-
-class AggrCheckTypes:
-    def __init__(self):
-        self.val = 0
-
-    def step(self, whichType, *vals):
-        theType = {"str": str, "int": int, "float": float, "None": type(None),
-                   "blob": bytes}
-        for val in vals:
-            self.val += int(theType[whichType] is type(val))
-
-    def finalize(self):
-        return self.val
-
-class AggrSum:
-    def __init__(self):
-        self.val = 0.0
-
-    def step(self, val):
-        self.val += val
-
-    def finalize(self):
-        return self.val
-
-class AggrText:
-    def __init__(self):
-        self.txt = ""
-    def step(self, txt):
-        self.txt = self.txt + txt
-    def finalize(self):
-        return self.txt
-
-
-class FunctionTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-
-        self.con.create_function("returntext", 0, func_returntext)
-        self.con.create_function("returntextwithnull", 0, func_returntextwithnull)
-        self.con.create_function("returnunicode", 0, func_returnunicode)
-        self.con.create_function("returnint", 0, func_returnint)
-        self.con.create_function("returnfloat", 0, func_returnfloat)
-        self.con.create_function("returnnull", 0, func_returnnull)
-        self.con.create_function("returnblob", 0, func_returnblob)
-        self.con.create_function("returnlonglong", 0, func_returnlonglong)
-        self.con.create_function("returnnan", 0, lambda: float("nan"))
-        self.con.create_function("returntoolargeint", 0, lambda: 1 << 65)
-        self.con.create_function("raiseexception", 0, func_raiseexception)
-
-        self.con.create_function("isblob", 1, lambda x: isinstance(x, bytes))
-        self.con.create_function("isnone", 1, lambda x: x is None)
-        self.con.create_function("spam", -1, lambda *x: len(x))
-        self.con.execute("create table test(t text)")
-
-    def tearDown(self):
-        self.con.close()
-
-    def test_func_error_on_create(self):
-        with self.assertRaises(sqlite.OperationalError):
-            self.con.create_function("bla", -100, lambda x: 2*x)
-
-    def test_func_ref_count(self):
-        def getfunc():
-            def f():
-                return 1
-            return f
-        f = getfunc()
-        globals()["foo"] = f
-        # self.con.create_function("reftest", 0, getfunc())
-        self.con.create_function("reftest", 0, f)
-        cur = self.con.cursor()
-        cur.execute("select reftest()")
-
-    def test_func_return_text(self):
-        cur = self.con.cursor()
-        cur.execute("select returntext()")
-        val = cur.fetchone()[0]
-        self.assertEqual(type(val), str)
-        self.assertEqual(val, "foo")
-
-    def test_func_return_text_with_null_char(self):
-        cur = self.con.cursor()
-        res = cur.execute("select returntextwithnull()").fetchone()[0]
-        self.assertEqual(type(res), str)
-        self.assertEqual(res, "1\x002")
-
-    def test_func_return_unicode(self):
-        cur = self.con.cursor()
-        cur.execute("select returnunicode()")
-        val = cur.fetchone()[0]
-        self.assertEqual(type(val), str)
-        self.assertEqual(val, "bar")
-
-    def test_func_return_int(self):
-        cur = self.con.cursor()
-        cur.execute("select returnint()")
-        val = cur.fetchone()[0]
-        self.assertEqual(type(val), int)
-        self.assertEqual(val, 42)
-
-    def test_func_return_float(self):
-        cur = self.con.cursor()
-        cur.execute("select returnfloat()")
-        val = cur.fetchone()[0]
-        self.assertEqual(type(val), float)
-        if val < 3.139 or val > 3.141:
-            self.fail("wrong value")
-
-    def test_func_return_null(self):
-        cur = self.con.cursor()
-        cur.execute("select returnnull()")
-        val = cur.fetchone()[0]
-        self.assertEqual(type(val), type(None))
-        self.assertEqual(val, None)
-
-    def test_func_return_blob(self):
-        cur = self.con.cursor()
-        cur.execute("select returnblob()")
-        val = cur.fetchone()[0]
-        self.assertEqual(type(val), bytes)
-        self.assertEqual(val, b"blob")
-
-    def test_func_return_long_long(self):
-        cur = self.con.cursor()
-        cur.execute("select returnlonglong()")
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 1<<31)
-
-    def test_func_return_nan(self):
-        cur = self.con.cursor()
-        cur.execute("select returnnan()")
-        self.assertIsNone(cur.fetchone()[0])
-
-    def test_func_return_too_large_int(self):
-        cur = self.con.cursor()
-        with self.assertRaises(sqlite.OperationalError):
-            self.con.execute("select returntoolargeint()")
-
-    def test_func_exception(self):
-        cur = self.con.cursor()
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            cur.execute("select raiseexception()")
-            cur.fetchone()
-        self.assertEqual(str(cm.exception), 'user-defined function raised exception')
-
-    def test_any_arguments(self):
-        cur = self.con.cursor()
-        cur.execute("select spam(?, ?)", (1, 2))
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 2)
-
-    def test_empty_blob(self):
-        cur = self.con.execute("select isblob(x'')")
-        self.assertTrue(cur.fetchone()[0])
-
-    def test_nan_float(self):
-        cur = self.con.execute("select isnone(?)", (float("nan"),))
-        # SQLite has no concept of nan; it is converted to NULL
-        self.assertTrue(cur.fetchone()[0])
-
-    def test_too_large_int(self):
-        err = "Python int too large to convert to SQLite INTEGER"
-        self.assertRaisesRegex(OverflowError, err, self.con.execute,
-                               "select spam(?)", (1 << 65,))
-
-    def test_non_contiguous_blob(self):
-        self.assertRaisesRegex(ValueError, "could not convert BLOB to buffer",
-                               self.con.execute, "select spam(?)",
-                               (memoryview(b"blob")[::2],))
-
-    def test_param_surrogates(self):
-        self.assertRaisesRegex(UnicodeEncodeError, "surrogates not allowed",
-                               self.con.execute, "select spam(?)",
-                               ("\ud803\ude6d",))
-
-    def test_func_params(self):
-        results = []
-        def append_result(arg):
-            results.append((arg, type(arg)))
-        self.con.create_function("test_params", 1, append_result)
-
-        dataset = [
-            (42, int),
-            (-1, int),
-            (1234567890123456789, int),
-            (4611686018427387905, int),  # 63-bit int with non-zero low bits
-            (3.14, float),
-            (float('inf'), float),
-            ("text", str),
-            ("1\x002", str),
-            ("\u02e2q\u02e1\u2071\u1d57\u1d49", str),
-            (b"blob", bytes),
-            (bytearray(range(2)), bytes),
-            (memoryview(b"blob"), bytes),
-            (None, type(None)),
-        ]
-        for val, _ in dataset:
-            cur = self.con.execute("select test_params(?)", (val,))
-            cur.fetchone()
-        self.assertEqual(dataset, results)
-
-    # Regarding deterministic functions:
-    #
-    # Between 3.8.3 and 3.15.0, deterministic functions were only used to
-    # optimize inner loops, so for those versions we can only test if the
-    # sqlite machinery has factored out a call or not. From 3.15.0 and onward,
-    # deterministic functions were permitted in WHERE clauses of partial
-    # indices, which allows testing based on syntax, iso. the query optimizer.
-    @unittest.skipIf(sqlite.sqlite_version_info < (3, 8, 3), "Requires SQLite 3.8.3 or higher")
-    def test_func_non_deterministic(self):
-        mock = unittest.mock.Mock(return_value=None)
-        self.con.create_function("nondeterministic", 0, mock, deterministic=False)
-        if sqlite.sqlite_version_info < (3, 15, 0):
-            self.con.execute("select nondeterministic() = nondeterministic()")
-            self.assertEqual(mock.call_count, 2)
-        else:
-            with self.assertRaises(sqlite.OperationalError):
-                self.con.execute("create index t on test(t) where nondeterministic() is not null")
-
-    @unittest.skipIf(sqlite.sqlite_version_info < (3, 8, 3), "Requires SQLite 3.8.3 or higher")
-    def test_func_deterministic(self):
-        mock = unittest.mock.Mock(return_value=None)
-        self.con.create_function("deterministic", 0, mock, deterministic=True)
-        if sqlite.sqlite_version_info < (3, 15, 0):
-            self.con.execute("select deterministic() = deterministic()")
-            self.assertEqual(mock.call_count, 1)
-        else:
-            try:
-                self.con.execute("create index t on test(t) where deterministic() is not null")
-            except sqlite.OperationalError:
-                self.fail("Unexpected failure while creating partial index")
-
-    @unittest.skipIf(sqlite.sqlite_version_info >= (3, 8, 3), "SQLite < 3.8.3 needed")
-    def test_func_deterministic_not_supported(self):
-        with self.assertRaises(sqlite.NotSupportedError):
-            self.con.create_function("deterministic", 0, int, deterministic=True)
-
-    def test_func_deterministic_keyword_only(self):
-        with self.assertRaises(TypeError):
-            self.con.create_function("deterministic", 0, int, True)
-
-    def test_function_destructor_via_gc(self):
-        # See bpo-44304: The destructor of the user function can
-        # crash if is called without the GIL from the gc functions
-        dest = sqlite.connect(':memory:')
-        def md5sum(t):
-            return
-
-        dest.create_function("md5", 1, md5sum)
-        x = dest("create table lang (name, first_appeared)")
-        del md5sum, dest
-
-        y = [x]
-        y.append(y)
-
-        del x,y
-        gc_collect()
-
-class AggregateTests(unittest.TestCase):
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-        cur = self.con.cursor()
-        cur.execute("""
-            create table test(
-                t text,
-                i integer,
-                f float,
-                n,
-                b blob
-                )
-            """)
-        cur.execute("insert into test(t, i, f, n, b) values (?, ?, ?, ?, ?)",
-            ("foo", 5, 3.14, None, memoryview(b"blob"),))
-
-        self.con.create_aggregate("nostep", 1, AggrNoStep)
-        self.con.create_aggregate("nofinalize", 1, AggrNoFinalize)
-        self.con.create_aggregate("excInit", 1, AggrExceptionInInit)
-        self.con.create_aggregate("excStep", 1, AggrExceptionInStep)
-        self.con.create_aggregate("excFinalize", 1, AggrExceptionInFinalize)
-        self.con.create_aggregate("checkType", 2, AggrCheckType)
-        self.con.create_aggregate("checkTypes", -1, AggrCheckTypes)
-        self.con.create_aggregate("mysum", 1, AggrSum)
-        self.con.create_aggregate("aggtxt", 1, AggrText)
-
-    def tearDown(self):
-        #self.cur.close()
-        #self.con.close()
-        pass
-
-    def test_aggr_error_on_create(self):
-        with self.assertRaises(sqlite.OperationalError):
-            self.con.create_function("bla", -100, AggrSum)
-
-    def test_aggr_no_step(self):
-        cur = self.con.cursor()
-        with self.assertRaises(AttributeError) as cm:
-            cur.execute("select nostep(t) from test")
-        self.assertEqual(str(cm.exception), "'AggrNoStep' object has no attribute 'step'")
-
-    def test_aggr_no_finalize(self):
-        cur = self.con.cursor()
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            cur.execute("select nofinalize(t) from test")
-            val = cur.fetchone()[0]
-        self.assertEqual(str(cm.exception), "user-defined aggregate's 'finalize' method raised error")
-
-    def test_aggr_exception_in_init(self):
-        cur = self.con.cursor()
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            cur.execute("select excInit(t) from test")
-            val = cur.fetchone()[0]
-        self.assertEqual(str(cm.exception), "user-defined aggregate's '__init__' method raised error")
-
-    def test_aggr_exception_in_step(self):
-        cur = self.con.cursor()
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            cur.execute("select excStep(t) from test")
-            val = cur.fetchone()[0]
-        self.assertEqual(str(cm.exception), "user-defined aggregate's 'step' method raised error")
-
-    def test_aggr_exception_in_finalize(self):
-        cur = self.con.cursor()
-        with self.assertRaises(sqlite.OperationalError) as cm:
-            cur.execute("select excFinalize(t) from test")
-            val = cur.fetchone()[0]
-        self.assertEqual(str(cm.exception), "user-defined aggregate's 'finalize' method raised error")
-
-    def test_aggr_check_param_str(self):
-        cur = self.con.cursor()
-        cur.execute("select checkTypes('str', ?, ?)", ("foo", str()))
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 2)
-
-    def test_aggr_check_param_int(self):
-        cur = self.con.cursor()
-        cur.execute("select checkType('int', ?)", (42,))
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 1)
-
-    def test_aggr_check_params_int(self):
-        cur = self.con.cursor()
-        cur.execute("select checkTypes('int', ?, ?)", (42, 24))
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 2)
-
-    def test_aggr_check_param_float(self):
-        cur = self.con.cursor()
-        cur.execute("select checkType('float', ?)", (3.14,))
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 1)
-
-    def test_aggr_check_param_none(self):
-        cur = self.con.cursor()
-        cur.execute("select checkType('None', ?)", (None,))
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 1)
-
-    def test_aggr_check_param_blob(self):
-        cur = self.con.cursor()
-        cur.execute("select checkType('blob', ?)", (memoryview(b"blob"),))
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 1)
-
-    def test_aggr_check_aggr_sum(self):
-        cur = self.con.cursor()
-        cur.execute("delete from test")
-        cur.executemany("insert into test(i) values (?)", [(10,), (20,), (30,)])
-        cur.execute("select mysum(i) from test")
-        val = cur.fetchone()[0]
-        self.assertEqual(val, 60)
-
-    def test_aggr_no_match(self):
-        cur = self.con.execute("select mysum(i) from (select 1 as i) where i == 0")
-        val = cur.fetchone()[0]
-        self.assertIsNone(val)
-
-    def test_aggr_text(self):
-        cur = self.con.cursor()
-        for txt in ["foo", "1\x002"]:
-            with self.subTest(txt=txt):
-                cur.execute("select aggtxt(?) from test", (txt,))
-                val = cur.fetchone()[0]
-                self.assertEqual(val, txt)
-
-
-class AuthorizerTests(unittest.TestCase):
-    @staticmethod
-    def authorizer_cb(action, arg1, arg2, dbname, source):
-        if action != sqlite.SQLITE_SELECT:
-            return sqlite.SQLITE_DENY
-        if arg2 == 'c2' or arg1 == 't2':
-            return sqlite.SQLITE_DENY
-        return sqlite.SQLITE_OK
-
-    def setUp(self):
-        self.con = sqlite.connect(":memory:")
-        self.con.executescript("""
-            create table t1 (c1, c2);
-            create table t2 (c1, c2);
-            insert into t1 (c1, c2) values (1, 2);
-            insert into t2 (c1, c2) values (4, 5);
-            """)
-
-        # For our security test:
-        self.con.execute("select c2 from t2")
-
-        self.con.set_authorizer(self.authorizer_cb)
-
-    def tearDown(self):
-        pass
-
-    def test_table_access(self):
-        with self.assertRaises(sqlite.DatabaseError) as cm:
-            self.con.execute("select * from t2")
-        self.assertIn('prohibited', str(cm.exception))
-
-    def test_column_access(self):
-        with self.assertRaises(sqlite.DatabaseError) as cm:
-            self.con.execute("select c2 from t1")
-        self.assertIn('prohibited', str(cm.exception))
-
-class AuthorizerRaiseExceptionTests(AuthorizerTests):
-    @staticmethod
-    def authorizer_cb(action, arg1, arg2, dbname, source):
-        if action != sqlite.SQLITE_SELECT:
-            raise ValueError
-        if arg2 == 'c2' or arg1 == 't2':
-            raise ValueError
-        return sqlite.SQLITE_OK
-
-class AuthorizerIllegalTypeTests(AuthorizerTests):
-    @staticmethod
-    def authorizer_cb(action, arg1, arg2, dbname, source):
-        if action != sqlite.SQLITE_SELECT:
-            return 0.0
-        if arg2 == 'c2' or arg1 == 't2':
-            return 0.0
-        return sqlite.SQLITE_OK
-
-class AuthorizerLargeIntegerTests(AuthorizerTests):
-    @staticmethod
-    def authorizer_cb(action, arg1, arg2, dbname, source):
-        if action != sqlite.SQLITE_SELECT:
-            return 2**32
-        if arg2 == 'c2' or arg1 == 't2':
-            return 2**32
-        return sqlite.SQLITE_OK
-
-
-def suite():
-    tests = [
-        AggregateTests,
-        AuthorizerIllegalTypeTests,
-        AuthorizerLargeIntegerTests,
-        AuthorizerRaiseExceptionTests,
-        AuthorizerTests,
-        FunctionTests,
-    ]
-    return unittest.TestSuite(
-        [unittest.TestLoader().loadTestsFromTestCase(t) for t in tests]
-    )
-
-def test():
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
-
-if __name__ == "__main__":
-    test()