ULTRA [ resource.optimyar.com ]

Linux uranus.pws-dns.net 5.14.0-570.46.1.el9_6.x86_64 #1 SMP PREEMPT_DYNAMIC Wed Sep 24 05:41:59 EDT 2025 x86_64

LiteSpeed

31.214.174.197 | Your IP: 216.73.216.214

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ opt / alt / python311 / lib64 / python3.11 / test /

Home Upload Mass Deface Mass Delete Back Connect Notify

test_clinic.py

# Argument Clinic
# Copyright 2012-2013 by Larry Hastings.
# Licensed to the PSF under a contributor agreement.

from functools import partial
from test import support, test_tools
from test.support import os_helper
from test.support import SHORT_TIMEOUT, requires_subprocess
from test.support.os_helper import TESTFN, unlink
from textwrap import dedent
from unittest import TestCase
import collections
import inspect
import os.path
import subprocess
import sys
import unittest

test_tools.skip_if_missing('clinic')
with test_tools.imports_under_tool('clinic'):
    import clinic
    from clinic import DSLParser

def restore_dict(converters, old_converters):
    converters.clear()
    converters.update(old_converters)

def save_restore_converters(testcase):
    testcase.addCleanup(restore_dict, clinic.converters,
                        clinic.converters.copy())
    testcase.addCleanup(restore_dict, clinic.legacy_converters,
                        clinic.legacy_converters.copy())
    testcase.addCleanup(restore_dict, clinic.return_converters,
                        clinic.return_converters.copy())

class _ParserBase(TestCase):
    maxDiff = None

def expect_parser_failure(self, parser, _input):
        with support.captured_stdout() as stdout:
            with self.assertRaises(SystemExit):
                parser(_input)
        return stdout.getvalue()

def parse_function_should_fail(self, _input):
        return self.expect_parser_failure(self.parse_function, _input)

class FakeConverter:
    def __init__(self, name, args):
        self.name = name
        self.args = args

class FakeConverterFactory:
    def __init__(self, name):
        self.name = name

def __call__(self, name, default, **kwargs):
        return FakeConverter(self.name, kwargs)

class FakeConvertersDict:
    def __init__(self):
        self.used_converters = {}

def get(self, name, default):
        return self.used_converters.setdefault(name, FakeConverterFactory(name))

c = clinic.Clinic(language='C', filename = "file")

class FakeClinic:
    def __init__(self):
        self.converters = FakeConvertersDict()
        self.legacy_converters = FakeConvertersDict()
        self.language = clinic.CLanguage(None)
        self.filename = None
        self.destination_buffers = {}
        self.block_parser = clinic.BlockParser('', self.language)
        self.modules = collections.OrderedDict()
        self.classes = collections.OrderedDict()
        clinic.clinic = self
        self.name = "FakeClinic"
        self.line_prefix = self.line_suffix = ''
        self.destinations = {}
        self.add_destination("block", "buffer")
        self.add_destination("file", "buffer")
        self.add_destination("suppress", "suppress")
        d = self.destinations.get
        self.field_destinations = collections.OrderedDict((
            ('docstring_prototype', d('suppress')),
            ('docstring_definition', d('block')),
            ('methoddef_define', d('block')),
            ('impl_prototype', d('block')),
            ('parser_prototype', d('suppress')),
            ('parser_definition', d('block')),
            ('impl_definition', d('block')),
        ))

def get_destination(self, name):
        d = self.destinations.get(name)
        if not d:
            sys.exit("Destination does not exist: " + repr(name))
        return d

def add_destination(self, name, type, *args):
        if name in self.destinations:
            sys.exit("Destination already exists: " + repr(name))
        self.destinations[name] = clinic.Destination(name, type, self, *args)

def is_directive(self, name):
        return name == "module"

def directive(self, name, args):
        self.called_directives[name] = args

_module_and_class = clinic.Clinic._module_and_class

class ClinicWholeFileTest(_ParserBase):
    def setUp(self):
        save_restore_converters(self)
        self.clinic = clinic.Clinic(clinic.CLanguage(None), filename="test.c")

def expect_failure(self, raw):
        _input = dedent(raw).strip()
        return self.expect_parser_failure(self.clinic.parse, _input)

def test_eol(self):
        # regression test:
        # clinic's block parser didn't recognize
        # the "end line" for the block if it
        # didn't end in "\n" (as in, the last)
        # byte of the file was '/'.
        # so it would spit out an end line for you.
        # and since you really already had one,
        # the last line of the block got corrupted.
        raw = "/*[clinic]\nfoo\n[clinic]*/"
        cooked = self.clinic.parse(raw).splitlines()
        end_line = cooked[2].rstrip()
        # this test is redundant, it's just here explicitly to catch
        # the regression test so we don't forget what it looked like
        self.assertNotEqual(end_line, "[clinic]*/[clinic]*/")
        self.assertEqual(end_line, "[clinic]*/")

def test_mangled_marker_line(self):
        raw = """
            /*[clinic input]
            [clinic start generated code]*/
            /*[clinic end generated code: foo]*/
        """
        msg = (
            'Error in file "test.c" on line 3:\n'
            "Mangled Argument Clinic marker line: '/*[clinic end generated code: foo]*/'\n"
        )
        out = self.expect_failure(raw)
        self.assertEqual(out, msg)

def test_checksum_mismatch(self):
        raw = """
            /*[clinic input]
            [clinic start generated code]*/
            /*[clinic end generated code: output=0123456789abcdef input=fedcba9876543210]*/
        """
        msg = (
            'Error in file "test.c" on line 3:\n'
            'Checksum mismatch!\n'
            'Expected: 0123456789abcdef\n'
            'Computed: da39a3ee5e6b4b0d\n'
        )
        out = self.expect_failure(raw)
        self.assertIn(msg, out)

def test_garbage_after_stop_line(self):
        raw = """
            /*[clinic input]
            [clinic start generated code]*/foobarfoobar!
        """
        msg = (
            'Error in file "test.c" on line 2:\n'
            "Garbage after stop line: 'foobarfoobar!'\n"
        )
        out = self.expect_failure(raw)
        self.assertEqual(out, msg)

def test_whitespace_before_stop_line(self):
        raw = """
            /*[clinic input]
             [clinic start generated code]*/
        """
        msg = (
            'Error in file "test.c" on line 2:\n'
            "Whitespace is not allowed before the stop line: ' [clinic start generated code]*/'\n"
        )
        out = self.expect_failure(raw)
        self.assertEqual(out, msg)

def test_parse_with_body_prefix(self):
        clang = clinic.CLanguage(None)
        clang.body_prefix = "//"
        clang.start_line = "//[{dsl_name} start]"
        clang.stop_line = "//[{dsl_name} stop]"
        cl = clinic.Clinic(clang, filename="test.c")
        raw = dedent("""
            //[clinic start]
            //module test
            //[clinic stop]
        """).strip()
        out = cl.parse(raw)
        expected = dedent("""
            //[clinic start]
            //module test
            //
            //[clinic stop]
            /*[clinic end generated code: output=da39a3ee5e6b4b0d input=65fab8adff58cf08]*/
        """).lstrip()  # Note, lstrip() because of the newline
        self.assertEqual(out, expected)

def test_cpp_monitor_fail_nested_block_comment(self):
        raw = """
            /* start
            /* nested
            */
            */
        """
        msg = (
            'Error in file "test.c" on line 2:\n'
            'Nested block comment!\n'
        )
        out = self.expect_failure(raw)
        self.assertEqual(out, msg)

def test_cpp_monitor_fail_invalid_format_noarg(self):
        raw = """
            #if
            a()
            #endif
        """
        msg = (
            'Error in file "test.c" on line 1:\n'
            'Invalid format for #if line: no argument!\n'
        )
        out = self.expect_failure(raw)
        self.assertEqual(out, msg)

def test_cpp_monitor_fail_invalid_format_toomanyargs(self):
        raw = """
            #ifdef A B
            a()
            #endif
        """
        msg = (
            'Error in file "test.c" on line 1:\n'
            'Invalid format for #ifdef line: should be exactly one argument!\n'
        )
        out = self.expect_failure(raw)
        self.assertEqual(out, msg)

def test_cpp_monitor_fail_no_matching_if(self):
        raw = '#else'
        msg = (
            'Error in file "test.c" on line 1:\n'
            '#else without matching #if / #ifdef / #ifndef!\n'
        )
        out = self.expect_failure(raw)
        self.assertEqual(out, msg)

def test_directive_output_unknown_preset(self):
        out = self.expect_failure("""
            /*[clinic input]
            output preset nosuchpreset
            [clinic start generated code]*/
        """)
        msg = "Unknown preset 'nosuchpreset'"
        self.assertIn(msg, out)

def test_directive_output_cant_pop(self):
        out = self.expect_failure("""
            /*[clinic input]
            output pop
            [clinic start generated code]*/
        """)
        msg = "Can't 'output pop', stack is empty"
        self.assertIn(msg, out)

def test_directive_output_print(self):
        raw = dedent("""
            /*[clinic input]
            output print 'I told you once.'
            [clinic start generated code]*/
        """)
        out = self.clinic.parse(raw)
        # The generated output will differ for every run, but we can check that
        # it starts with the clinic block, we check that it contains all the
        # expected fields, and we check that it contains the checksum line.
        self.assertTrue(out.startswith(dedent("""
            /*[clinic input]
            output print 'I told you once.'
            [clinic start generated code]*/
        """)))
        fields = {
            "cpp_endif",
            "cpp_if",
            "docstring_definition",
            "docstring_prototype",
            "impl_definition",
            "impl_prototype",
            "methoddef_define",
            "methoddef_ifndef",
            "parser_definition",
            "parser_prototype",
        }
        for field in fields:
            with self.subTest(field=field):
                self.assertIn(field, out)
        last_line = out.rstrip().split("\n")[-1]
        self.assertTrue(
            last_line.startswith("/*[clinic end generated code: output=")
        )

def test_unknown_destination_command(self):
        out = self.expect_failure("""
            /*[clinic input]
            destination buffer nosuchcommand
            [clinic start generated code]*/
        """)
        msg = "unknown destination command 'nosuchcommand'"
        self.assertIn(msg, out)

def test_no_access_to_members_in_converter_init(self):
        out = self.expect_failure("""
            /*[python input]
            class Custom_converter(CConverter):
                converter = "some_c_function"
                def converter_init(self):
                    self.function.noaccess
            [python start generated code]*/
            /*[clinic input]
            module test
            test.fn
                a: Custom
            [clinic start generated code]*/
        """)
        msg = (
            "Stepped on a land mine, trying to access attribute 'noaccess':\n"
            "Don't access members of self.function inside converter_init!"
        )
        self.assertIn(msg, out)

class ClinicGroupPermuterTest(TestCase):
    def _test(self, l, m, r, output):
        computed = clinic.permute_optional_groups(l, m, r)
        self.assertEqual(output, computed)

def test_range(self):
        self._test([['start']], ['stop'], [['step']],
          (
            ('stop',),
            ('start', 'stop',),
            ('start', 'stop', 'step',),
          ))

def test_add_window(self):
        self._test([['x', 'y']], ['ch'], [['attr']],
          (
            ('ch',),
            ('ch', 'attr'),
            ('x', 'y', 'ch',),
            ('x', 'y', 'ch', 'attr'),
          ))

def test_ludicrous(self):
        self._test([['a1', 'a2', 'a3'], ['b1', 'b2']], ['c1'], [['d1', 'd2'], ['e1', 'e2', 'e3']],
          (
          ('c1',),
          ('b1', 'b2', 'c1'),
          ('b1', 'b2', 'c1', 'd1', 'd2'),
          ('a1', 'a2', 'a3', 'b1', 'b2', 'c1'),
          ('a1', 'a2', 'a3', 'b1', 'b2', 'c1', 'd1', 'd2'),
          ('a1', 'a2', 'a3', 'b1', 'b2', 'c1', 'd1', 'd2', 'e1', 'e2', 'e3'),
          ))

def test_right_only(self):
        self._test([], [], [['a'],['b'],['c']],
          (
          (),
          ('a',),
          ('a', 'b'),
          ('a', 'b', 'c')
          ))

def test_have_left_options_but_required_is_empty(self):
        def fn():
            clinic.permute_optional_groups(['a'], [], [])
        self.assertRaises(AssertionError, fn)

class ClinicLinearFormatTest(TestCase):
    def _test(self, input, output, **kwargs):
        computed = clinic.linear_format(input, **kwargs)
        self.assertEqual(output, computed)

def test_empty_strings(self):
        self._test('', '')

def test_solo_newline(self):
        self._test('\n', '\n')

def test_no_substitution(self):
        self._test("""
          abc
        """, """
          abc
        """)

def test_empty_substitution(self):
        self._test("""
          abc
          {name}
          def
        """, """
          abc
          def
        """, name='')

def test_single_line_substitution(self):
        self._test("""
          abc
          {name}
          def
        """, """
          abc
          GARGLE
          def
        """, name='GARGLE')

def test_multiline_substitution(self):
        self._test("""
          abc
          {name}
          def
        """, """
          abc
          bingle
          bungle

def
        """, name='bingle\nbungle\n')

class InertParser:
    def __init__(self, clinic):
        pass

def parse(self, block):
        pass

class CopyParser:
    def __init__(self, clinic):
        pass

def parse(self, block):
        block.output = block.input

class ClinicBlockParserTest(TestCase):
    def _test(self, input, output):
        language = clinic.CLanguage(None)

blocks = list(clinic.BlockParser(input, language))
        writer = clinic.BlockPrinter(language)
        for block in blocks:
            writer.print_block(block)
        output = writer.f.getvalue()
        assert output == input, "output != input!\n\noutput " + repr(output) + "\n\n input " + repr(input)

def round_trip(self, input):
        return self._test(input, input)

def test_round_trip_1(self):
        self.round_trip("""
            verbatim text here
            lah dee dah
        """)
    def test_round_trip_2(self):
        self.round_trip("""
    verbatim text here
    lah dee dah
/*[inert]
abc
[inert]*/
def
/*[inert checksum: 7b18d017f89f61cf17d47f92749ea6930a3f1deb]*/
xyz
""")

def _test_clinic(self, input, output):
        language = clinic.CLanguage(None)
        c = clinic.Clinic(language, filename="file")
        c.parsers['inert'] = InertParser(c)
        c.parsers['copy'] = CopyParser(c)
        computed = c.parse(input)
        self.assertEqual(output, computed)

def test_clinic_1(self):
        self._test_clinic("""
    verbatim text here
    lah dee dah
/*[copy input]
def
[copy start generated code]*/
abc
/*[copy end generated code: output=03cfd743661f0797 input=7b18d017f89f61cf]*/
xyz
""", """
    verbatim text here
    lah dee dah
/*[copy input]
def
[copy start generated code]*/
def
/*[copy end generated code: output=7b18d017f89f61cf input=7b18d017f89f61cf]*/
xyz
""")

class ClinicParserTest(_ParserBase):
    def checkDocstring(self, fn, expected):
        self.assertTrue(hasattr(fn, "docstring"))
        self.assertEqual(fn.docstring.strip(),
                         dedent(expected).strip())

def test_trivial(self):
        parser = DSLParser(FakeClinic())
        block = clinic.Block("""
            module os
            os.access
        """)
        parser.parse(block)
        module, function = block.signatures
        self.assertEqual("access", function.name)
        self.assertEqual("os", module.name)

def test_ignore_line(self):
        block = self.parse(dedent("""
            #
            module os
            os.access
        """))
        module, function = block.signatures
        self.assertEqual("access", function.name)
        self.assertEqual("os", module.name)

def test_param(self):
        function = self.parse_function("""
            module os
            os.access
                path: int
        """)
        self.assertEqual("access", function.name)
        self.assertEqual(2, len(function.parameters))
        p = function.parameters['path']
        self.assertEqual('path', p.name)
        self.assertIsInstance(p.converter, clinic.int_converter)

def test_param_default(self):
        function = self.parse_function("""
            module os
            os.access
                follow_symlinks: bool = True
        """)
        p = function.parameters['follow_symlinks']
        self.assertEqual(True, p.default)

def test_param_with_continuations(self):
        function = self.parse_function(r"""
            module os
            os.access
                follow_symlinks: \
                bool \
                = \
                True
        """)
        p = function.parameters['follow_symlinks']
        self.assertEqual(True, p.default)

def test_param_default_expression(self):
        function = self.parse_function("""
            module os
            os.access
                follow_symlinks: int(c_default='MAXSIZE') = sys.maxsize
            """)
        p = function.parameters['follow_symlinks']
        self.assertEqual(sys.maxsize, p.default)
        self.assertEqual("MAXSIZE", p.converter.c_default)

expected_msg = (
            "Error on line 0:\n"
            "When you specify a named constant ('sys.maxsize') as your default value,\n"
            "you MUST specify a valid c_default.\n"
        )
        out = self.parse_function_should_fail("""
            module os
            os.access
                follow_symlinks: int = sys.maxsize
        """)
        self.assertEqual(out, expected_msg)

def test_param_no_docstring(self):
        function = self.parse_function("""
            module os
            os.access
                follow_symlinks: bool = True
                something_else: str = ''
        """)
        p = function.parameters['follow_symlinks']
        self.assertEqual(3, len(function.parameters))
        conv = function.parameters['something_else'].converter
        self.assertIsInstance(conv, clinic.str_converter)

def test_param_default_parameters_out_of_order(self):
        expected_msg = (
            "Error on line 0:\n"
            "Can't have a parameter without a default ('something_else')\n"
            "after a parameter with a default!\n"
        )
        out = self.parse_function_should_fail("""
            module os
            os.access
                follow_symlinks: bool = True
                something_else: str""")
        self.assertEqual(out, expected_msg)

def disabled_test_converter_arguments(self):
        function = self.parse_function("""
            module os
            os.access
                path: path_t(allow_fd=1)
        """)
        p = function.parameters['path']
        self.assertEqual(1, p.converter.args['allow_fd'])

def test_function_docstring(self):
        function = self.parse_function("""
            module os
            os.stat as os_stat_fn

path: str
                   Path to be examined

Perform a stat system call on the given path.
        """)
        self.checkDocstring(function, """
            stat($module, /, path)
            --

Perform a stat system call on the given path.

path
                Path to be examined
        """)

def test_explicit_parameters_in_docstring(self):
        function = self.parse_function(dedent("""
            module foo
            foo.bar
              x: int
                 Documentation for x.
              y: int

This is the documentation for foo.

Okay, we're done here.
        """))
        self.checkDocstring(function, """
            bar($module, /, x, y)
            --

This is the documentation for foo.

x
                Documentation for x.

Okay, we're done here.
        """)

def test_parser_regression_special_character_in_parameter_column_of_docstring_first_line(self):
        function = self.parse_function(dedent("""
            module os
            os.stat
                path: str
            This/used to break Clinic!
        """))
        self.checkDocstring(function, """
            stat($module, /, path)
            --

This/used to break Clinic!
        """)

def test_c_name(self):
        function = self.parse_function("""
            module os
            os.stat as os_stat_fn
        """)
        self.assertEqual("os_stat_fn", function.c_basename)

def test_return_converter(self):
        function = self.parse_function("""
            module os
            os.stat -> int
        """)
        self.assertIsInstance(function.return_converter, clinic.int_return_converter)

def test_star(self):
        function = self.parse_function("""
            module os
            os.access
                *
                follow_symlinks: bool = True
        """)
        p = function.parameters['follow_symlinks']
        self.assertEqual(inspect.Parameter.KEYWORD_ONLY, p.kind)
        self.assertEqual(0, p.group)

def test_group(self):
        function = self.parse_function("""
            module window
            window.border
                [
                ls: int
                ]
                /
        """)
        p = function.parameters['ls']
        self.assertEqual(1, p.group)

def test_left_group(self):
        function = self.parse_function("""
            module curses
            curses.addch
                [
                y: int
                    Y-coordinate.
                x: int
                    X-coordinate.
                ]
                ch: char
                    Character to add.
                [
                attr: long
                    Attributes for the character.
                ]
                /
        """)
        dataset = (
            ('y', -1), ('x', -1),
            ('ch', 0),
            ('attr', 1),
        )
        for name, group in dataset:
            with self.subTest(name=name, group=group):
                p = function.parameters[name]
                self.assertEqual(p.group, group)
                self.assertEqual(p.kind, inspect.Parameter.POSITIONAL_ONLY)
        self.checkDocstring(function, """
            addch([y, x,] ch, [attr])

y
                Y-coordinate.
              x
                X-coordinate.
              ch
                Character to add.
              attr
                Attributes for the character.
        """)

def test_nested_groups(self):
        function = self.parse_function("""
            module curses
            curses.imaginary
               [
               [
               y1: int
                 Y-coordinate.
               y2: int
                 Y-coordinate.
               ]
               x1: int
                 X-coordinate.
               x2: int
                 X-coordinate.
               ]
               ch: char
                 Character to add.
               [
               attr1: long
                 Attributes for the character.
               attr2: long
                 Attributes for the character.
               attr3: long
                 Attributes for the character.
               [
               attr4: long
                 Attributes for the character.
               attr5: long
                 Attributes for the character.
               attr6: long
                 Attributes for the character.
               ]
               ]
               /
        """)
        dataset = (
            ('y1', -2), ('y2', -2),
            ('x1', -1), ('x2', -1),
            ('ch', 0),
            ('attr1', 1), ('attr2', 1), ('attr3', 1),
            ('attr4', 2), ('attr5', 2), ('attr6', 2),
        )
        for name, group in dataset:
            with self.subTest(name=name, group=group):
                p = function.parameters[name]
                self.assertEqual(p.group, group)
                self.assertEqual(p.kind, inspect.Parameter.POSITIONAL_ONLY)

self.checkDocstring(function, """
            imaginary([[y1, y2,] x1, x2,] ch, [attr1, attr2, attr3, [attr4, attr5,
                      attr6]])

y1
                Y-coordinate.
              y2
                Y-coordinate.
              x1
                X-coordinate.
              x2
                X-coordinate.
              ch
                Character to add.
              attr1
                Attributes for the character.
              attr2
                Attributes for the character.
              attr3
                Attributes for the character.
              attr4
                Attributes for the character.
              attr5
                Attributes for the character.
              attr6
                Attributes for the character.
        """)

def parse_function_should_fail(self, s):
        with support.captured_stdout() as stdout:
            with self.assertRaises(SystemExit):
                self.parse_function(s)
        return stdout.getvalue()

def test_disallowed_grouping__two_top_groups_on_left(self):
        expected_msg = (
            'Error on line 0:\n'
            'Function two_top_groups_on_left has an unsupported group '
            'configuration. (Unexpected state 2.b)\n'
        )
        out = self.parse_function_should_fail("""
            module foo
            foo.two_top_groups_on_left
                [
                group1 : int
                ]
                [
                group2 : int
                ]
                param: int
        """)
        self.assertEqual(out, expected_msg)

def test_disallowed_grouping__two_top_groups_on_right(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.two_top_groups_on_right
                param: int
                [
                group1 : int
                ]
                [
                group2 : int
                ]
        """)
        msg = (
            "Function two_top_groups_on_right has an unsupported group "
            "configuration. (Unexpected state 6.b)"
        )
        self.assertIn(msg, out)

def test_disallowed_grouping__parameter_after_group_on_right(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.parameter_after_group_on_right
                param: int
                [
                [
                group1 : int
                ]
                group2 : int
                ]
        """)
        msg = (
            "Function parameter_after_group_on_right has an unsupported group "
            "configuration. (Unexpected state 6.a)"
        )
        self.assertIn(msg, out)

def test_disallowed_grouping__group_after_parameter_on_left(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.group_after_parameter_on_left
                [
                group2 : int
                [
                group1 : int
                ]
                ]
                param: int
        """)
        msg = (
            "Function group_after_parameter_on_left has an unsupported group "
            "configuration. (Unexpected state 2.b)"
        )
        self.assertIn(msg, out)

def test_disallowed_grouping__empty_group_on_left(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.empty_group
                [
                [
                ]
                group2 : int
                ]
                param: int
        """)
        msg = (
            "Function empty_group has an empty group.\n"
            "All groups must contain at least one parameter."
        )
        self.assertIn(msg, out)

def test_disallowed_grouping__empty_group_on_right(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.empty_group
                param: int
                [
                [
                ]
                group2 : int
                ]
        """)
        msg = (
            "Function empty_group has an empty group.\n"
            "All groups must contain at least one parameter."
        )
        self.assertIn(msg, out)

def test_disallowed_grouping__no_matching_bracket(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.empty_group
                param: int
                ]
                group2: int
                ]
        """)
        msg = "Function empty_group has a ] without a matching [."
        self.assertIn(msg, out)

def test_no_parameters(self):
        function = self.parse_function("""
            module foo
            foo.bar

Docstring

""")
        self.assertEqual("bar($module, /)\n--\n\nDocstring", function.docstring)
        self.assertEqual(1, len(function.parameters)) # self!

def test_init_with_no_parameters(self):
        function = self.parse_function("""
            module foo
            class foo.Bar "unused" "notneeded"
            foo.Bar.__init__

Docstring

""", signatures_in_block=3, function_index=2)

# self is not in the signature
        self.assertEqual("Bar()\n--\n\nDocstring", function.docstring)
        # but it *is* a parameter
        self.assertEqual(1, len(function.parameters))

def test_illegal_module_line(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar => int
                /
        """)
        msg = "Illegal function name: foo.bar => int"
        self.assertIn(msg, out)

def test_illegal_c_basename(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar as 935
                /
        """)
        msg = "Illegal C basename: 935"
        self.assertIn(msg, out)

def test_single_star(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar
                *
                *
        """)
        self.assertIn("Function bar uses '*' more than once.", out)

def test_parameters_required_after_star(self):
        dataset = (
            "module foo\nfoo.bar\n  *",
            "module foo\nfoo.bar\n  *\nDocstring here.",
            "module foo\nfoo.bar\n  this: int\n  *",
            "module foo\nfoo.bar\n  this: int\n  *\nDocstring.",
        )
        msg = "Function bar specifies '*' without any parameters afterwards."
        for block in dataset:
            with self.subTest(block=block):
                out = self.parse_function_should_fail(block)
                self.assertIn(msg, out)

def test_single_slash(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar
                /
                /
        """)
        msg = (
            "Function bar has an unsupported group configuration. "
            "(Unexpected state 0.d)"
        )
        self.assertIn(msg, out)

def test_double_slash(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar
                a: int
                /
                b: int
                /
        """)
        msg = "Function bar uses '/' more than once."
        self.assertIn(msg, out)

def test_mix_star_and_slash(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar
               x: int
               y: int
               *
               z: int
               /
        """)
        msg = (
            "Function bar mixes keyword-only and positional-only parameters, "
            "which is unsupported."
        )
        self.assertIn(msg, out)

def test_parameters_not_permitted_after_slash_for_now(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar
                /
                x: int
        """)
        msg = (
            "Function bar has an unsupported group configuration. "
            "(Unexpected state 0.d)"
        )
        self.assertIn(msg, out)

def test_parameters_no_more_than_one_vararg(self):
        expected_msg = (
            "Error on line 0:\n"
            "Too many var args\n"
        )
        out = self.parse_function_should_fail("""
            module foo
            foo.bar
               *vararg1: object
               *vararg2: object
        """)
        self.assertEqual(out, expected_msg)

def test_function_not_at_column_0(self):
        function = self.parse_function("""
              module foo
              foo.bar
                x: int
                  Nested docstring here, goeth.
                *
                y: str
              Not at column 0!
        """)
        self.checkDocstring(function, """
            bar($module, /, x, *, y)
            --

Not at column 0!

x
                Nested docstring here, goeth.
        """)

def test_indent_stack_no_tabs(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar
               *vararg1: object
            \t*vararg2: object
        """)
        msg = "Tab characters are illegal in the Clinic DSL."
        self.assertIn(msg, out)

def test_indent_stack_illegal_outdent(self):
        out = self.parse_function_should_fail("""
            module foo
            foo.bar
              a: object
             b: object
        """)
        self.assertIn("Illegal outdent", out)

def test_directive(self):
        c = FakeClinic()
        parser = DSLParser(c)
        parser.flag = False
        parser.directives['setflag'] = lambda : setattr(parser, 'flag', True)
        block = clinic.Block("setflag")
        parser.parse(block)
        self.assertTrue(parser.flag)

def test_legacy_converters(self):
        block = self.parse('module os\nos.access\n   path: "s"')
        module, function = block.signatures
        conv = (function.parameters['path']).converter
        self.assertIsInstance(conv, clinic.str_converter)

def test_legacy_converters_non_string_constant_annotation(self):
        expected_failure_message = (
            "Error on line 0:\n"
            "Annotations must be either a name, a function call, or a string.\n"
        )
        dataset = (
            'module os\nos.access\n   path: 42',
            'module os\nos.access\n   path: 42.42',
            'module os\nos.access\n   path: 42j',
            'module os\nos.access\n   path: b"42"',
        )
        for block in dataset:
            with self.subTest(block=block):
                out = self.parse_function_should_fail(block)
                self.assertEqual(out, expected_failure_message)

def test_other_bizarre_things_in_annotations_fail(self):
        expected_failure_message = (
            "Error on line 0:\n"
            "Annotations must be either a name, a function call, or a string.\n"
        )
        dataset = (
            'module os\nos.access\n   path: {"some": "dictionary"}',
            'module os\nos.access\n   path: ["list", "of", "strings"]',
            'module os\nos.access\n   path: (x for x in range(42))',
        )
        for block in dataset:
            with self.subTest(block=block):
                out = self.parse_function_should_fail(block)
                self.assertEqual(out, expected_failure_message)

def test_self_param_placement(self):
        expected_error_msg = (
            "Error on line 0:\n"
            "A 'self' parameter, if specified, must be the very first thing "
            "in the parameter block.\n"
        )
        block = """
            module foo
            foo.func
                a: int
                self: self(type="PyObject *")
        """
        out = self.parse_function_should_fail(block)
        self.assertEqual(out, expected_error_msg)

def test_self_param_cannot_be_optional(self):
        expected_error_msg = (
            "Error on line 0:\n"
            "A 'self' parameter cannot be marked optional.\n"
        )
        block = """
            module foo
            foo.func
                self: self(type="PyObject *") = None
        """
        out = self.parse_function_should_fail(block)
        self.assertEqual(out, expected_error_msg)

def test_defining_class_param_placement(self):
        expected_error_msg = (
            "Error on line 0:\n"
            "A 'defining_class' parameter, if specified, must either be the "
            "first thing in the parameter block, or come just after 'self'.\n"
        )
        block = """
            module foo
            foo.func
                self: self(type="PyObject *")
                a: int
                cls: defining_class
        """
        out = self.parse_function_should_fail(block)
        self.assertEqual(out, expected_error_msg)

def test_defining_class_param_cannot_be_optional(self):
        expected_error_msg = (
            "Error on line 0:\n"
            "A 'defining_class' parameter cannot be marked optional.\n"
        )
        block = """
            module foo
            foo.func
                cls: defining_class(type="PyObject *") = None
        """
        out = self.parse_function_should_fail(block)
        self.assertEqual(out, expected_error_msg)

def test_slot_methods_cannot_access_defining_class(self):
        block = """
            module foo
            class Foo "" ""
            Foo.__init__
                cls: defining_class
                a: object
        """
        msg = "Slot methods cannot access their defining class."
        with self.assertRaisesRegex(ValueError, msg):
            self.parse_function(block)

def test_new_must_be_a_class_method(self):
        expected_error_msg = (
            "Error on line 0:\n"
            "__new__ must be a class method!\n"
        )
        out = self.parse_function_should_fail("""
            module foo
            class Foo "" ""
            Foo.__new__
        """)
        self.assertEqual(out, expected_error_msg)

def test_init_must_be_a_normal_method(self):
        expected_error_msg = (
            "Error on line 0:\n"
            "__init__ must be a normal method, not a class or static method!\n"
        )
        out = self.parse_function_should_fail("""
            module foo
            class Foo "" ""
            @classmethod
            Foo.__init__
        """)
        self.assertEqual(out, expected_error_msg)

def parse(self, text):
        c = FakeClinic()
        parser = DSLParser(c)
        block = clinic.Block(text)
        parser.parse(block)
        return block

def parse_function(self, text, signatures_in_block=2, function_index=1):
        block = self.parse(text)
        s = block.signatures
        self.assertEqual(len(s), signatures_in_block)
        assert isinstance(s[0], clinic.Module)
        assert isinstance(s[function_index], clinic.Function)
        return s[function_index]

def test_scaffolding(self):
        # test repr on special values
        self.assertEqual(repr(clinic.unspecified), '<Unspecified>')
        self.assertEqual(repr(clinic.NULL), '<Null>')

# test that fail fails
        expected = (
            'Error in file "clown.txt" on line 69:\n'
            'The igloos are melting!\n'
        )
        with support.captured_stdout() as stdout:
            with self.assertRaises(SystemExit):
                clinic.fail('The igloos are melting!',
                            filename='clown.txt', line_number=69)
        actual = stdout.getvalue()
        self.assertEqual(actual, expected)

class ClinicExternalTest(TestCase):
    maxDiff = None
    clinic_py = os.path.join(test_tools.toolsdir, "clinic", "clinic.py")

def setUp(self):
        save_restore_converters(self)

def _do_test(self, *args, expect_success=True):
        with subprocess.Popen(
            [sys.executable, "-Xutf8", self.clinic_py, *args],
            encoding="utf-8",
            bufsize=0,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
        ) as proc:
            proc.wait()
            if expect_success and proc.returncode:
                self.fail("".join([*proc.stdout, *proc.stderr]))
            stdout = proc.stdout.read()
            stderr = proc.stderr.read()
            # Clinic never writes to stderr.
            self.assertEqual(stderr, "")
            return stdout

def expect_success(self, *args):
        return self._do_test(*args)

def expect_failure(self, *args):
        return self._do_test(*args, expect_success=False)

def test_external(self):
        CLINIC_TEST = 'clinic.test.c'
        source = support.findfile(CLINIC_TEST)
        with open(source, 'r', encoding='utf-8') as f:
            orig_contents = f.read()

# Run clinic CLI and verify that it does not complain.
        self.addCleanup(unlink, TESTFN)
        out = self.expect_success("-f", "-o", TESTFN, source)
        self.assertEqual(out, "")

with open(TESTFN, 'r', encoding='utf-8') as f:
            new_contents = f.read()

self.assertEqual(new_contents, orig_contents)

def test_no_change(self):
        # bpo-42398: Test that the destination file is left unchanged if the
        # content does not change. Moreover, check also that the file
        # modification time does not change in this case.
        code = dedent("""
            /*[clinic input]
            [clinic start generated code]*/
            /*[clinic end generated code: output=da39a3ee5e6b4b0d input=da39a3ee5e6b4b0d]*/
        """)
        with os_helper.temp_dir() as tmp_dir:
            fn = os.path.join(tmp_dir, "test.c")
            with open(fn, "w", encoding="utf-8") as f:
                f.write(code)
            pre_mtime = os.stat(fn).st_mtime_ns
            self.expect_success(fn)
            post_mtime = os.stat(fn).st_mtime_ns
        # Don't change the file modification time
        # if the content does not change
        self.assertEqual(pre_mtime, post_mtime)

def test_cli_force(self):
        invalid_input = dedent("""
            /*[clinic input]
            output preset block
            module test
            test.fn
                a: int
            [clinic start generated code]*/

const char *hand_edited = "output block is overwritten";
            /*[clinic end generated code: output=bogus input=bogus]*/
        """)
        fail_msg = dedent("""
            Checksum mismatch!
            Expected: bogus
            Computed: 2ed19
            Suggested fix: remove all generated code including the end marker,
            or use the '-f' option.
        """)
        with os_helper.temp_dir() as tmp_dir:
            fn = os.path.join(tmp_dir, "test.c")
            with open(fn, "w", encoding="utf-8") as f:
                f.write(invalid_input)
            # First, run the CLI without -f and expect failure.
            # Note, we cannot check the entire fail msg, because the path to
            # the tmp file will change for every run.
            out = self.expect_failure(fn)
            self.assertTrue(out.endswith(fail_msg))
            # Then, force regeneration; success expected.
            out = self.expect_success("-f", fn)
            self.assertEqual(out, "")
            # Verify by checking the checksum.
            checksum = (
                "/*[clinic end generated code: "
                "output=6c2289b73f32bc19 input=9543a8d2da235301]*/\n"
            )
            with open(fn, 'r', encoding='utf-8') as f:
                generated = f.read()
            self.assertTrue(generated.endswith(checksum))

def test_cli_make(self):
        c_code = dedent("""
            /*[clinic input]
            [clinic start generated code]*/
        """)
        py_code = "pass"
        c_files = "file1.c", "file2.c"
        py_files = "file1.py", "file2.py"

def create_files(files, srcdir, code):
            for fn in files:
                path = os.path.join(srcdir, fn)
                with open(path, "w", encoding="utf-8") as f:
                    f.write(code)

with os_helper.temp_dir() as tmp_dir:
            # add some folders, some C files and a Python file
            create_files(c_files, tmp_dir, c_code)
            create_files(py_files, tmp_dir, py_code)

# create C files in externals/ dir
            ext_path = os.path.join(tmp_dir, "externals")
            with os_helper.temp_dir(path=ext_path) as externals:
                create_files(c_files, externals, c_code)

# run clinic in verbose mode with --make on tmpdir
                out = self.expect_success("-v", "--make", "--srcdir", tmp_dir)

# expect verbose mode to only mention the C files in tmp_dir
            for filename in c_files:
                with self.subTest(filename=filename):
                    path = os.path.join(tmp_dir, filename)
                    self.assertIn(path, out)
            for filename in py_files:
                with self.subTest(filename=filename):
                    path = os.path.join(tmp_dir, filename)
                    self.assertNotIn(path, out)
            # don't expect C files from the externals dir
            for filename in c_files:
                with self.subTest(filename=filename):
                    path = os.path.join(ext_path, filename)
                    self.assertNotIn(path, out)

def test_cli_verbose(self):
        with os_helper.temp_dir() as tmp_dir:
            fn = os.path.join(tmp_dir, "test.c")
            with open(fn, "w", encoding="utf-8") as f:
                f.write("")
            out = self.expect_success("-v", fn)
            self.assertEqual(out.strip(), fn)

def test_cli_help(self):
        out = self.expect_success("-h")
        self.assertIn("usage: clinic.py", out)

def test_cli_converters(self):
        prelude = dedent("""
            Legacy converters:
                B C D L O S U Y Z Z#
                b c d f h i l p s s# s* u u# w* y y# y* z z# z*

Converters:
        """)
        expected_converters = (
            "bool",
            "byte",
            "char",
            "defining_class",
            "double",
            "fildes",
            "float",
            "int",
            "long",
            "long_long",
            "object",
            "Py_buffer",
            "Py_complex",
            "Py_ssize_t",
            "Py_UNICODE",
            "PyByteArrayObject",
            "PyBytesObject",
            "self",
            "short",
            "size_t",
            "slice_index",
            "str",
            "unicode",
            "unsigned_char",
            "unsigned_int",
            "unsigned_long",
            "unsigned_long_long",
            "unsigned_short",
        )
        finale = dedent("""
            Return converters:
                bool()
                double()
                float()
                init()
                int()
                long()
                NoneType()
                Py_ssize_t()
                size_t()
                unsigned_int()
                unsigned_long()

All converters also accept (c_default=None, py_default=None, annotation=None).
            All return converters also accept (py_default=None).
        """)
        out = self.expect_success("--converters")
        # We cannot simply compare the output, because the repr of the *accept*
        # param may change (it's a set, thus unordered). So, let's compare the
        # start and end of the expected output, and then assert that the
        # converters appear lined up in alphabetical order.
        self.assertTrue(out.startswith(prelude), out)
        self.assertTrue(out.endswith(finale), out)

out = out.removeprefix(prelude)
        out = out.removesuffix(finale)
        lines = out.split("\n")
        for converter, line in zip(expected_converters, lines):
            line = line.lstrip()
            with self.subTest(converter=converter):
                self.assertTrue(
                    line.startswith(converter),
                    f"expected converter {converter!r}, got {line!r}"
                )

def test_cli_fail_converters_and_filename(self):
        out = self.expect_failure("--converters", "test.c")
        msg = (
            "Usage error: can't specify --converters "
            "and a filename at the same time"
        )
        self.assertIn(msg, out)

def test_cli_fail_no_filename(self):
        out = self.expect_failure()
        self.assertIn("usage: clinic.py", out)

def test_cli_fail_output_and_multiple_files(self):
        out = self.expect_failure("-o", "out.c", "input.c", "moreinput.c")
        msg = "Usage error: can't use -o with multiple filenames"
        self.assertIn(msg, out)

def test_cli_fail_filename_or_output_and_make(self):
        for opts in ("-o", "out.c"), ("filename.c",):
            with self.subTest(opts=opts):
                out = self.expect_failure("--make", *opts)
                msg = "Usage error: can't use -o or filenames with --make"
                self.assertIn(msg, out)

def test_cli_fail_make_without_srcdir(self):
        out = self.expect_failure("--make", "--srcdir", "")
        msg = "Usage error: --srcdir must not be empty with --make"
        self.assertIn(msg, out)

try:
    import _testclinic as ac_tester
except ImportError:
    ac_tester = None

@unittest.skipIf(ac_tester is None, "_testclinic is missing")
class ClinicFunctionalTest(unittest.TestCase):
    locals().update((name, getattr(ac_tester, name))
                    for name in dir(ac_tester) if name.startswith('test_'))

def test_objects_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.objects_converter()
        self.assertEqual(ac_tester.objects_converter(1, 2), (1, 2))
        self.assertEqual(ac_tester.objects_converter([], 'whatever class'), ([], 'whatever class'))
        self.assertEqual(ac_tester.objects_converter(1), (1, None))

def test_bytes_object_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.bytes_object_converter(1)
        self.assertEqual(ac_tester.bytes_object_converter(b'BytesObject'), (b'BytesObject',))

def test_byte_array_object_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.byte_array_object_converter(1)
        byte_arr = bytearray(b'ByteArrayObject')
        self.assertEqual(ac_tester.byte_array_object_converter(byte_arr), (byte_arr,))

def test_unicode_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.unicode_converter(1)
        self.assertEqual(ac_tester.unicode_converter('unicode'), ('unicode',))

def test_bool_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.bool_converter(False, False, 'not a int')
        self.assertEqual(ac_tester.bool_converter(), (True, True, True))
        self.assertEqual(ac_tester.bool_converter('', [], 5), (False, False, True))
        self.assertEqual(ac_tester.bool_converter(('not empty',), {1: 2}, 0), (True, True, False))

def test_char_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.char_converter(1)
        with self.assertRaises(TypeError):
            ac_tester.char_converter(b'ab')
        chars = [b'A', b'\a', b'\b', b'\t', b'\n', b'\v', b'\f', b'\r', b'"', b"'", b'?', b'\\', b'\000', b'\377']
        expected = tuple(ord(c) for c in chars)
        self.assertEqual(ac_tester.char_converter(), expected)
        chars = [b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'0', b'a', b'b', b'c', b'd']
        expected = tuple(ord(c) for c in chars)
        self.assertEqual(ac_tester.char_converter(*chars), expected)

def test_unsigned_char_converter(self):
        from _testcapi import UCHAR_MAX
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_char_converter(-1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_char_converter(UCHAR_MAX + 1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_char_converter(0, UCHAR_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.unsigned_char_converter([])
        self.assertEqual(ac_tester.unsigned_char_converter(), (12, 34, 56))
        self.assertEqual(ac_tester.unsigned_char_converter(0, 0, UCHAR_MAX + 1), (0, 0, 0))
        self.assertEqual(ac_tester.unsigned_char_converter(0, 0, (UCHAR_MAX + 1) * 3 + 123), (0, 0, 123))

def test_short_converter(self):
        from _testcapi import SHRT_MIN, SHRT_MAX
        with self.assertRaises(OverflowError):
            ac_tester.short_converter(SHRT_MIN - 1)
        with self.assertRaises(OverflowError):
            ac_tester.short_converter(SHRT_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.short_converter([])
        self.assertEqual(ac_tester.short_converter(-1234), (-1234,))
        self.assertEqual(ac_tester.short_converter(4321), (4321,))

def test_unsigned_short_converter(self):
        from _testcapi import USHRT_MAX
        with self.assertRaises(ValueError):
            ac_tester.unsigned_short_converter(-1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_short_converter(USHRT_MAX + 1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_short_converter(0, USHRT_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.unsigned_short_converter([])
        self.assertEqual(ac_tester.unsigned_short_converter(), (12, 34, 56))
        self.assertEqual(ac_tester.unsigned_short_converter(0, 0, USHRT_MAX + 1), (0, 0, 0))
        self.assertEqual(ac_tester.unsigned_short_converter(0, 0, (USHRT_MAX + 1) * 3 + 123), (0, 0, 123))

def test_int_converter(self):
        from _testcapi import INT_MIN, INT_MAX
        with self.assertRaises(OverflowError):
            ac_tester.int_converter(INT_MIN - 1)
        with self.assertRaises(OverflowError):
            ac_tester.int_converter(INT_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.int_converter(1, 2, 3)
        with self.assertRaises(TypeError):
            ac_tester.int_converter([])
        self.assertEqual(ac_tester.int_converter(), (12, 34, 45))
        self.assertEqual(ac_tester.int_converter(1, 2, '3'), (1, 2, ord('3')))

def test_unsigned_int_converter(self):
        from _testcapi import UINT_MAX
        with self.assertRaises(ValueError):
            ac_tester.unsigned_int_converter(-1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_int_converter(UINT_MAX + 1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_int_converter(0, UINT_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.unsigned_int_converter([])
        self.assertEqual(ac_tester.unsigned_int_converter(), (12, 34, 56))
        self.assertEqual(ac_tester.unsigned_int_converter(0, 0, UINT_MAX + 1), (0, 0, 0))
        self.assertEqual(ac_tester.unsigned_int_converter(0, 0, (UINT_MAX + 1) * 3 + 123), (0, 0, 123))

def test_long_converter(self):
        from _testcapi import LONG_MIN, LONG_MAX
        with self.assertRaises(OverflowError):
            ac_tester.long_converter(LONG_MIN - 1)
        with self.assertRaises(OverflowError):
            ac_tester.long_converter(LONG_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.long_converter([])
        self.assertEqual(ac_tester.long_converter(), (12,))
        self.assertEqual(ac_tester.long_converter(-1234), (-1234,))

def test_unsigned_long_converter(self):
        from _testcapi import ULONG_MAX
        with self.assertRaises(ValueError):
            ac_tester.unsigned_long_converter(-1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_long_converter(ULONG_MAX + 1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_long_converter(0, ULONG_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.unsigned_long_converter([])
        self.assertEqual(ac_tester.unsigned_long_converter(), (12, 34, 56))
        self.assertEqual(ac_tester.unsigned_long_converter(0, 0, ULONG_MAX + 1), (0, 0, 0))
        self.assertEqual(ac_tester.unsigned_long_converter(0, 0, (ULONG_MAX + 1) * 3 + 123), (0, 0, 123))

def test_long_long_converter(self):
        from _testcapi import LLONG_MIN, LLONG_MAX
        with self.assertRaises(OverflowError):
            ac_tester.long_long_converter(LLONG_MIN - 1)
        with self.assertRaises(OverflowError):
            ac_tester.long_long_converter(LLONG_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.long_long_converter([])
        self.assertEqual(ac_tester.long_long_converter(), (12,))
        self.assertEqual(ac_tester.long_long_converter(-1234), (-1234,))

def test_unsigned_long_long_converter(self):
        from _testcapi import ULLONG_MAX
        with self.assertRaises(ValueError):
            ac_tester.unsigned_long_long_converter(-1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_long_long_converter(ULLONG_MAX + 1)
        with self.assertRaises(OverflowError):
            ac_tester.unsigned_long_long_converter(0, ULLONG_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.unsigned_long_long_converter([])
        self.assertEqual(ac_tester.unsigned_long_long_converter(), (12, 34, 56))
        self.assertEqual(ac_tester.unsigned_long_long_converter(0, 0, ULLONG_MAX + 1), (0, 0, 0))
        self.assertEqual(ac_tester.unsigned_long_long_converter(0, 0, (ULLONG_MAX + 1) * 3 + 123), (0, 0, 123))

def test_py_ssize_t_converter(self):
        from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
        with self.assertRaises(OverflowError):
            ac_tester.py_ssize_t_converter(PY_SSIZE_T_MIN - 1)
        with self.assertRaises(OverflowError):
            ac_tester.py_ssize_t_converter(PY_SSIZE_T_MAX + 1)
        with self.assertRaises(TypeError):
            ac_tester.py_ssize_t_converter([])
        self.assertEqual(ac_tester.py_ssize_t_converter(), (12, 34, 56))
        self.assertEqual(ac_tester.py_ssize_t_converter(1, 2, None), (1, 2, 56))

def test_slice_index_converter(self):
        from _testcapi import PY_SSIZE_T_MIN, PY_SSIZE_T_MAX
        with self.assertRaises(TypeError):
            ac_tester.slice_index_converter([])
        self.assertEqual(ac_tester.slice_index_converter(), (12, 34, 56))
        self.assertEqual(ac_tester.slice_index_converter(1, 2, None), (1, 2, 56))
        self.assertEqual(ac_tester.slice_index_converter(PY_SSIZE_T_MAX, PY_SSIZE_T_MAX + 1, PY_SSIZE_T_MAX + 1234),
                         (PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX))
        self.assertEqual(ac_tester.slice_index_converter(PY_SSIZE_T_MIN, PY_SSIZE_T_MIN - 1, PY_SSIZE_T_MIN - 1234),
                         (PY_SSIZE_T_MIN, PY_SSIZE_T_MIN, PY_SSIZE_T_MIN))

def test_size_t_converter(self):
        with self.assertRaises(ValueError):
            ac_tester.size_t_converter(-1)
        with self.assertRaises(TypeError):
            ac_tester.size_t_converter([])
        self.assertEqual(ac_tester.size_t_converter(), (12,))

def test_float_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.float_converter([])
        self.assertEqual(ac_tester.float_converter(), (12.5,))
        self.assertEqual(ac_tester.float_converter(-0.5), (-0.5,))

def test_double_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.double_converter([])
        self.assertEqual(ac_tester.double_converter(), (12.5,))
        self.assertEqual(ac_tester.double_converter(-0.5), (-0.5,))

def test_py_complex_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.py_complex_converter([])
        self.assertEqual(ac_tester.py_complex_converter(complex(1, 2)), (complex(1, 2),))
        self.assertEqual(ac_tester.py_complex_converter(complex('-1-2j')), (complex('-1-2j'),))
        self.assertEqual(ac_tester.py_complex_converter(-0.5), (-0.5,))
        self.assertEqual(ac_tester.py_complex_converter(10), (10,))

def test_str_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.str_converter(1)
        with self.assertRaises(TypeError):
            ac_tester.str_converter('a', 'b', 'c')
        with self.assertRaises(ValueError):
            ac_tester.str_converter('a', b'b\0b', 'c')
        self.assertEqual(ac_tester.str_converter('a', b'b', 'c'), ('a', 'b', 'c'))
        self.assertEqual(ac_tester.str_converter('a', b'b', b'c'), ('a', 'b', 'c'))
        self.assertEqual(ac_tester.str_converter('a', b'b', 'c\0c'), ('a', 'b', 'c\0c'))

def test_str_converter_encoding(self):
        with self.assertRaises(TypeError):
            ac_tester.str_converter_encoding(1)
        self.assertEqual(ac_tester.str_converter_encoding('a', 'b', 'c'), ('a', 'b', 'c'))
        with self.assertRaises(TypeError):
            ac_tester.str_converter_encoding('a', b'b\0b', 'c')
        self.assertEqual(ac_tester.str_converter_encoding('a', b'b', bytearray([ord('c')])), ('a', 'b', 'c'))
        self.assertEqual(ac_tester.str_converter_encoding('a', b'b', bytearray([ord('c'), 0, ord('c')])),
                         ('a', 'b', 'c\x00c'))
        self.assertEqual(ac_tester.str_converter_encoding('a', b'b', b'c\x00c'), ('a', 'b', 'c\x00c'))

def test_py_buffer_converter(self):
        with self.assertRaises(TypeError):
            ac_tester.py_buffer_converter('a', 'b')
        self.assertEqual(ac_tester.py_buffer_converter('abc', bytearray([1, 2, 3])), (b'abc', b'\x01\x02\x03'))

def test_keywords(self):
        self.assertEqual(ac_tester.keywords(1, 2), (1, 2))
        self.assertEqual(ac_tester.keywords(1, b=2), (1, 2))
        self.assertEqual(ac_tester.keywords(a=1, b=2), (1, 2))

def test_keywords_kwonly(self):
        with self.assertRaises(TypeError):
            ac_tester.keywords_kwonly(1, 2)
        self.assertEqual(ac_tester.keywords_kwonly(1, b=2), (1, 2))
        self.assertEqual(ac_tester.keywords_kwonly(a=1, b=2), (1, 2))

def test_keywords_opt(self):
        self.assertEqual(ac_tester.keywords_opt(1), (1, None, None))
        self.assertEqual(ac_tester.keywords_opt(1, 2), (1, 2, None))
        self.assertEqual(ac_tester.keywords_opt(1, 2, 3), (1, 2, 3))
        self.assertEqual(ac_tester.keywords_opt(1, b=2), (1, 2, None))
        self.assertEqual(ac_tester.keywords_opt(1, 2, c=3), (1, 2, 3))
        self.assertEqual(ac_tester.keywords_opt(a=1, c=3), (1, None, 3))
        self.assertEqual(ac_tester.keywords_opt(a=1, b=2, c=3), (1, 2, 3))

def test_keywords_opt_kwonly(self):
        self.assertEqual(ac_tester.keywords_opt_kwonly(1), (1, None, None, None))
        self.assertEqual(ac_tester.keywords_opt_kwonly(1, 2), (1, 2, None, None))
        with self.assertRaises(TypeError):
            ac_tester.keywords_opt_kwonly(1, 2, 3)
        self.assertEqual(ac_tester.keywords_opt_kwonly(1, b=2), (1, 2, None, None))
        self.assertEqual(ac_tester.keywords_opt_kwonly(1, 2, c=3), (1, 2, 3, None))
        self.assertEqual(ac_tester.keywords_opt_kwonly(a=1, c=3), (1, None, 3, None))
        self.assertEqual(ac_tester.keywords_opt_kwonly(a=1, b=2, c=3, d=4), (1, 2, 3, 4))

def test_keywords_kwonly_opt(self):
        self.assertEqual(ac_tester.keywords_kwonly_opt(1), (1, None, None))
        with self.assertRaises(TypeError):
            ac_tester.keywords_kwonly_opt(1, 2)
        self.assertEqual(ac_tester.keywords_kwonly_opt(1, b=2), (1, 2, None))
        self.assertEqual(ac_tester.keywords_kwonly_opt(a=1, c=3), (1, None, 3))
        self.assertEqual(ac_tester.keywords_kwonly_opt(a=1, b=2, c=3), (1, 2, 3))

def test_posonly_keywords(self):
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords(1)
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords(a=1, b=2)
        self.assertEqual(ac_tester.posonly_keywords(1, 2), (1, 2))
        self.assertEqual(ac_tester.posonly_keywords(1, b=2), (1, 2))

def test_posonly_kwonly(self):
        with self.assertRaises(TypeError):
            ac_tester.posonly_kwonly(1)
        with self.assertRaises(TypeError):
            ac_tester.posonly_kwonly(1, 2)
        with self.assertRaises(TypeError):
            ac_tester.posonly_kwonly(a=1, b=2)
        self.assertEqual(ac_tester.posonly_kwonly(1, b=2), (1, 2))

def test_posonly_keywords_kwonly(self):
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_kwonly(1)
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_kwonly(1, 2, 3)
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_kwonly(a=1, b=2, c=3)
        self.assertEqual(ac_tester.posonly_keywords_kwonly(1, 2, c=3), (1, 2, 3))
        self.assertEqual(ac_tester.posonly_keywords_kwonly(1, b=2, c=3), (1, 2, 3))

def test_posonly_keywords_opt(self):
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_opt(1)
        self.assertEqual(ac_tester.posonly_keywords_opt(1, 2), (1, 2, None, None))
        self.assertEqual(ac_tester.posonly_keywords_opt(1, 2, 3), (1, 2, 3, None))
        self.assertEqual(ac_tester.posonly_keywords_opt(1, 2, 3, 4), (1, 2, 3, 4))
        self.assertEqual(ac_tester.posonly_keywords_opt(1, b=2), (1, 2, None, None))
        self.assertEqual(ac_tester.posonly_keywords_opt(1, 2, c=3), (1, 2, 3, None))
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_opt(a=1, b=2, c=3, d=4)
        self.assertEqual(ac_tester.posonly_keywords_opt(1, b=2, c=3, d=4), (1, 2, 3, 4))

def test_posonly_opt_keywords_opt(self):
        self.assertEqual(ac_tester.posonly_opt_keywords_opt(1), (1, None, None, None))
        self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2), (1, 2, None, None))
        self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2, 3), (1, 2, 3, None))
        self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2, 3, 4), (1, 2, 3, 4))
        with self.assertRaises(TypeError):
            ac_tester.posonly_opt_keywords_opt(1, b=2)
        self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2, c=3), (1, 2, 3, None))
        self.assertEqual(ac_tester.posonly_opt_keywords_opt(1, 2, c=3, d=4), (1, 2, 3, 4))
        with self.assertRaises(TypeError):
            ac_tester.posonly_opt_keywords_opt(a=1, b=2, c=3, d=4)

def test_posonly_kwonly_opt(self):
        with self.assertRaises(TypeError):
            ac_tester.posonly_kwonly_opt(1)
        with self.assertRaises(TypeError):
            ac_tester.posonly_kwonly_opt(1, 2)
        self.assertEqual(ac_tester.posonly_kwonly_opt(1, b=2), (1, 2, None, None))
        self.assertEqual(ac_tester.posonly_kwonly_opt(1, b=2, c=3), (1, 2, 3, None))
        self.assertEqual(ac_tester.posonly_kwonly_opt(1, b=2, c=3, d=4), (1, 2, 3, 4))
        with self.assertRaises(TypeError):
            ac_tester.posonly_kwonly_opt(a=1, b=2, c=3, d=4)

def test_posonly_opt_kwonly_opt(self):
        self.assertEqual(ac_tester.posonly_opt_kwonly_opt(1), (1, None, None, None))
        self.assertEqual(ac_tester.posonly_opt_kwonly_opt(1, 2), (1, 2, None, None))
        with self.assertRaises(TypeError):
            ac_tester.posonly_opt_kwonly_opt(1, 2, 3)
        with self.assertRaises(TypeError):
            ac_tester.posonly_opt_kwonly_opt(1, b=2)
        self.assertEqual(ac_tester.posonly_opt_kwonly_opt(1, 2, c=3), (1, 2, 3, None))
        self.assertEqual(ac_tester.posonly_opt_kwonly_opt(1, 2, c=3, d=4), (1, 2, 3, 4))

def test_posonly_keywords_kwonly_opt(self):
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_kwonly_opt(1)
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_kwonly_opt(1, 2)
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_kwonly_opt(1, b=2)
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_kwonly_opt(1, 2, 3)
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_kwonly_opt(a=1, b=2, c=3)
        self.assertEqual(ac_tester.posonly_keywords_kwonly_opt(1, 2, c=3), (1, 2, 3, None, None))
        self.assertEqual(ac_tester.posonly_keywords_kwonly_opt(1, b=2, c=3), (1, 2, 3, None, None))
        self.assertEqual(ac_tester.posonly_keywords_kwonly_opt(1, 2, c=3, d=4), (1, 2, 3, 4, None))
        self.assertEqual(ac_tester.posonly_keywords_kwonly_opt(1, 2, c=3, d=4, e=5), (1, 2, 3, 4, 5))

def test_posonly_keywords_opt_kwonly_opt(self):
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_opt_kwonly_opt(1)
        self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2), (1, 2, None, None, None))
        self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, b=2), (1, 2, None, None, None))
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, 3, 4)
        with self.assertRaises(TypeError):
            ac_tester.posonly_keywords_opt_kwonly_opt(a=1, b=2)
        self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, c=3), (1, 2, 3, None, None))
        self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, b=2, c=3), (1, 2, 3, None, None))
        self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, 3, d=4), (1, 2, 3, 4, None))
        self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, c=3, d=4), (1, 2, 3, 4, None))
        self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, 3, d=4, e=5), (1, 2, 3, 4, 5))
        self.assertEqual(ac_tester.posonly_keywords_opt_kwonly_opt(1, 2, c=3, d=4, e=5), (1, 2, 3, 4, 5))

def test_posonly_opt_keywords_opt_kwonly_opt(self):
        self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1), (1, None, None, None))
        self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2), (1, 2, None, None))
        with self.assertRaises(TypeError):
            ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, b=2)
        self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, 3), (1, 2, 3, None))
        self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, c=3), (1, 2, 3, None))
        self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, 3, d=4), (1, 2, 3, 4))
        self.assertEqual(ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, c=3, d=4), (1, 2, 3, 4))
        with self.assertRaises(TypeError):
            ac_tester.posonly_opt_keywords_opt_kwonly_opt(1, 2, 3, 4)

def test_keyword_only_parameter(self):
        with self.assertRaises(TypeError):
            ac_tester.keyword_only_parameter()
        with self.assertRaises(TypeError):
            ac_tester.keyword_only_parameter(1)
        self.assertEqual(ac_tester.keyword_only_parameter(a=1), (1,))

def test_posonly_vararg(self):
        with self.assertRaises(TypeError):
            ac_tester.posonly_vararg()
        self.assertEqual(ac_tester.posonly_vararg(1, 2), (1, 2, ()))
        self.assertEqual(ac_tester.posonly_vararg(1, b=2), (1, 2, ()))
        self.assertEqual(ac_tester.posonly_vararg(1, 2, 3, 4), (1, 2, (3, 4)))

def test_vararg_and_posonly(self):
        with self.assertRaises(TypeError):
            ac_tester.vararg_and_posonly()
        with self.assertRaises(TypeError):
            ac_tester.vararg_and_posonly(1, b=2)
        self.assertEqual(ac_tester.vararg_and_posonly(1, 2, 3, 4), (1, (2, 3, 4)))

def test_vararg(self):
        with self.assertRaises(TypeError):
            ac_tester.vararg()
        with self.assertRaises(TypeError):
            ac_tester.vararg(1, b=2)
        self.assertEqual(ac_tester.vararg(1, 2, 3, 4), (1, (2, 3, 4)))

def test_vararg_with_default(self):
        with self.assertRaises(TypeError):
            ac_tester.vararg_with_default()
        self.assertEqual(ac_tester.vararg_with_default(1, b=False), (1, (), False))
        self.assertEqual(ac_tester.vararg_with_default(1, 2, 3, 4), (1, (2, 3, 4), False))
        self.assertEqual(ac_tester.vararg_with_default(1, 2, 3, 4, b=True), (1, (2, 3, 4), True))

def test_vararg_with_only_defaults(self):
        self.assertEqual(ac_tester.vararg_with_only_defaults(), ((), None))
        self.assertEqual(ac_tester.vararg_with_only_defaults(b=2), ((), 2))
        self.assertEqual(ac_tester.vararg_with_only_defaults(1, b=2), ((1, ), 2))
        self.assertEqual(ac_tester.vararg_with_only_defaults(1, 2, 3, 4), ((1, 2, 3, 4), None))
        self.assertEqual(ac_tester.vararg_with_only_defaults(1, 2, 3, 4, b=5), ((1, 2, 3, 4), 5))

def test_gh_32092_oob(self):
        ac_tester.gh_32092_oob(1, 2, 3, 4, kw1=5, kw2=6)

def test_gh_32092_kw_pass(self):
        ac_tester.gh_32092_kw_pass(1, 2, 3)

def test_gh_99233_refcount(self):
        arg = '*A unique string is not referenced by anywhere else.*'
        arg_refcount_origin = sys.getrefcount(arg)
        ac_tester.gh_99233_refcount(arg)
        arg_refcount_after = sys.getrefcount(arg)
        self.assertEqual(arg_refcount_origin, arg_refcount_after)

def test_gh_99240_double_free(self):
        expected_error = r'gh_99240_double_free argument 2 must be encoded string without null bytes, not str'
        with self.assertRaisesRegex(TypeError, expected_error):
            ac_tester.gh_99240_double_free('a', '\0b')

def test_meth_method_no_params(self):
        obj = ac_tester.TestClass()
        meth = obj.meth_method_no_params
        check = partial(self.assertRaisesRegex, TypeError, "no arguments")
        check(meth, 1)
        check(meth, a=1)

def test_meth_method_no_params_capi(self):
        from _testcapi import pyobject_vectorcall
        obj = ac_tester.TestClass()
        meth = obj.meth_method_no_params
        pyobject_vectorcall(meth, None, None)
        pyobject_vectorcall(meth, (), None)
        pyobject_vectorcall(meth, (), ())
        pyobject_vectorcall(meth, None, ())

check = partial(self.assertRaisesRegex, TypeError, "no arguments")
        check(pyobject_vectorcall, meth, (1,), None)
        check(pyobject_vectorcall, meth, (1,), ("a",))

class PermutationTests(unittest.TestCase):
    """Test permutation support functions."""

def test_permute_left_option_groups(self):
        expected = (
            (),
            (3,),
            (2, 3),
            (1, 2, 3),
        )
        data = list(zip([1, 2, 3]))  # Generate a list of 1-tuples.
        actual = tuple(clinic.permute_left_option_groups(data))
        self.assertEqual(actual, expected)

def test_permute_right_option_groups(self):
        expected = (
            (),
            (1,),
            (1, 2),
            (1, 2, 3),
        )
        data = list(zip([1, 2, 3]))  # Generate a list of 1-tuples.
        actual = tuple(clinic.permute_right_option_groups(data))
        self.assertEqual(actual, expected)

def test_permute_optional_groups(self):
        empty = {
            "left": (), "required": (), "right": (),
            "expected": ((),),
        }
        noleft1 = {
            "left": (), "required": ("b",), "right": ("c",),
            "expected": (
                ("b",),
                ("b", "c"),
            ),
        }
        noleft2 = {
            "left": (), "required": ("b", "c",), "right": ("d",),
            "expected": (
                ("b", "c"),
                ("b", "c", "d"),
            ),
        }
        noleft3 = {
            "left": (), "required": ("b", "c",), "right": ("d", "e"),
            "expected": (
                ("b", "c"),
                ("b", "c", "d"),
                ("b", "c", "d", "e"),
            ),
        }
        noright1 = {
            "left": ("a",), "required": ("b",), "right": (),
            "expected": (
                ("b",),
                ("a", "b"),
            ),
        }
        noright2 = {
            "left": ("a",), "required": ("b", "c"), "right": (),
            "expected": (
                ("b", "c"),
                ("a", "b", "c"),
            ),
        }
        noright3 = {
            "left": ("a", "b"), "required": ("c",), "right": (),
            "expected": (
                ("c",),
                ("b", "c"),
                ("a", "b", "c"),
            ),
        }
        leftandright1 = {
            "left": ("a",), "required": ("b",), "right": ("c",),
            "expected": (
                ("b",),
                ("a", "b"),  # Prefer left.
                ("a", "b", "c"),
            ),
        }
        leftandright2 = {
            "left": ("a", "b"), "required": ("c", "d"), "right": ("e", "f"),
            "expected": (
                ("c", "d"),
                ("b", "c", "d"),       # Prefer left.
                ("a", "b", "c", "d"),  # Prefer left.
                ("a", "b", "c", "d", "e"),
                ("a", "b", "c", "d", "e", "f"),
            ),
        }
        dataset = (
            empty,
            noleft1, noleft2, noleft3,
            noright1, noright2, noright3,
            leftandright1, leftandright2,
        )
        for params in dataset:
            with self.subTest(**params):
                left, required, right, expected = params.values()
                permutations = clinic.permute_optional_groups(left, required, right)
                actual = tuple(permutations)
                self.assertEqual(actual, expected)

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

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
..	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:06
__pycache__	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
audiodata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
certdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
cjkencodings	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
configdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
crashers	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
data	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
decimaltestdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
dtracedata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
encoded_modules	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
imghdrdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
leakers	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
libregrtest	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
regrtestdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-23 04:49:53
sndhdrdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
subprocessdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
support	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_asyncio	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_capi	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_concurrent_futures	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_cppext	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_dataclasses	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_doctest	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_email	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_future_stmt	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_gdb	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_import	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_importlib	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_inspect	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_json	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_module	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_multiprocessing_fork	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_multiprocessing_forkserver	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_multiprocessing_spawn	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_peg_generator	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_pydoc	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_sqlite3	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_tomllib	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_tools	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_warnings	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
test_zoneinfo	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
tokenizedata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
tracedmodules	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
typinganndata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
xmltestdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
ziptestdata	dir	-	root/linksafe	drwxr-xr-x	2025-06-29 12:10:53
Sine-1000Hz-300ms.aif	audio/x-aiff	60.25 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
__init__.py	text/plain	47 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
__main__.py	text/x-script.python	67 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
_test_atexit.py	text/plain	3.61 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
_test_eintr.py	text/plain	17.75 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
_test_embed_set_config.py	text/x-script.python	8.68 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
_test_embed_structseq.py	text/x-script.python	1.83 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
_test_multiprocessing.py	text/x-script.python	204.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
_test_venv_multiprocessing.py	text/x-script.python	762 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
archiver_tests.py	text/plain	6.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
audiotest.au	audio/basic	27.48 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
audiotests.py	text/x-script.python	12.13 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
audit-tests.py	text/plain	11.55 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
autotest.py	text/x-script.python	214 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
bisect_cmd.py	text/x-script.python	5.34 KB	root/linksafe	-rwxr-xr-x	2025-06-03 06:38:25
clinic.test.c	text/plain	118.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
cmath_testcases.txt	text/plain	141.05 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
curses_tests.py	text/plain	1.23 KB	root/linksafe	-rwxr-xr-x	2025-06-03 06:38:25
datetimetester.py	text/plain	257.92 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
dis_module.py	text/plain	76 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
empty.vbs	text/plain	70 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
exception_hierarchy.txt	text/plain	2.33 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
floating_points.txt	text/plain	15.92 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
fork_wait.py	text/plain	2.18 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
formatfloat_testcases.txt	text/plain	7.45 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
ieee754.txt	text/plain	3.15 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
imp_dummy.py	text/plain	63 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
list_tests.py	text/plain	16.65 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
lock_tests.py	text/plain	35.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
mailcap.txt	text/plain	1.24 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
mapping_tests.py	text/x-script.python	21.83 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
math_testcases.txt	text/plain	23.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
memory_watchdog.py	text/plain	859 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
mime.types	text/plain	47.37 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
mock_socket.py	text/plain	3.7 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
mp_fork_bomb.py	text/plain	448 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
mp_preload.py	text/x-script.python	351 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
multibytecodec_support.py	text/x-script.python	14.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
pickletester.py	text/x-script.python	143.84 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
profilee.py	text/plain	2.97 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
pstats.pck	application/octet-stream	65.05 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
pyclbr_input.py	text/plain	648 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
pythoninfo.py	text/plain	28.32 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
randv2_32.pck	text/plain	7.34 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
randv2_64.pck	text/plain	7.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
randv3.pck	text/plain	7.82 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
re_tests.py	text/plain	25.94 KB	root/linksafe	-rwxr-xr-x	2025-06-03 06:38:25
recursion.tar	application/x-tar	516 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
regrtest.py	text/plain	1.28 KB	root/linksafe	-rwxr-xr-x	2025-06-03 06:38:25
relimport.py	text/x-script.python	27 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
reperf.py	text/x-script.python	538 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
seq_tests.py	text/plain	14.96 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
signalinterproctester.py	text/x-script.python	3.08 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
ssl_servers.py	text/x-script.python	7.12 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
ssltests.py	text/plain	1.03 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
string_tests.py	text/plain	69.05 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test___all__.py	text/x-script.python	5.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test__locale.py	text/x-script.python	8.09 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test__opcode.py	text/x-script.python	4.14 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test__osx_support.py	text/plain	13.62 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test__xxsubinterpreters.py	text/x-script.python	78.84 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_abc.py	text/x-script.python	23.65 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_abstract_numbers.py	text/plain	5.81 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_aifc.py	text/x-script.python	17.84 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_argparse.py	text/x-script.python	187.05 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_array.py	text/plain	55.27 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_asdl_parser.py	text/plain	4.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ast.py	text/x-script.python	118.11 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_asyncgen.py	text/x-script.python	46.94 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_asynchat.py	text/x-script.python	9.46 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_asyncore.py	text/x-script.python	26.11 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_atexit.py	text/x-script.python	3.21 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_audioop.py	text/x-script.python	28.32 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_audit.py	text/plain	6.91 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_augassign.py	text/x-script.python	7.68 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_base64.py	text/x-script.python	35.08 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_baseexception.py	text/x-script.python	7.77 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_bdb.py	text/plain	43.7 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_bigaddrspace.py	text/plain	2.83 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_bigmem.py	text/plain	45.01 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_binascii.py	text/plain	19.37 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_binop.py	text/plain	14.14 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_bisect.py	text/x-script.python	15.71 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_bool.py	text/x-script.python	13.02 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_buffer.py	text/x-script.python	160.38 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_bufio.py	text/x-script.python	2.58 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_builtin.py	text/x-script.python	92.55 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_bytes.py	text/plain	79.63 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_bz2.py	text/x-script.python	42.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_c_locale_coercion.py	text/x-script.python	20.99 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_calendar.py	text/x-script.python	51.01 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_call.py	text/x-script.python	26.57 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_cgi.py	text/x-script.python	22.27 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_cgitb.py	text/x-script.python	2.62 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_charmapcodec.py	text/plain	1.77 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_check_c_globals.py	text/plain	1.02 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_class.py	text/x-script.python	19.33 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_clinic.py	text/x-script.python	76.86 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_cmath.py	text/x-script.python	24.14 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_cmd.py	text/plain	6.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_cmd_line.py	text/x-script.python	39.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_cmd_line_script.py	text/x-script.python	34.91 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_code.py	text/plain	23.29 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_code_module.py	text/x-script.python	5.53 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codeccallbacks.py	text/x-script.python	49.22 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecencodings_cn.py	text/x-script.python	3.86 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecencodings_hk.py	text/x-script.python	701 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecencodings_iso2022.py	text/x-script.python	3.65 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecencodings_jp.py	text/x-script.python	4.79 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecencodings_kr.py	text/x-script.python	2.96 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecencodings_tw.py	text/x-script.python	681 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecmaps_cn.py	text/x-script.python	746 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecmaps_hk.py	text/x-script.python	386 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecmaps_jp.py	text/x-script.python	1.7 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecmaps_kr.py	text/x-script.python	1.16 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecmaps_tw.py	text/x-script.python	705 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codecs.py	text/x-script.python	139.04 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_codeop.py	text/plain	9.62 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_collections.py	text/plain	92.34 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_colorsys.py	text/x-script.python	4.27 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_compare.py	text/plain	17.46 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_compile.py	text/x-script.python	59.92 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_compileall.py	text/x-script.python	48.27 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_complex.py	text/x-script.python	32.89 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_configparser.py	text/x-script.python	86.84 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_contains.py	text/x-script.python	3.35 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_context.py	text/x-script.python	30.78 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_contextlib.py	text/plain	41.2 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_contextlib_async.py	text/x-script.python	23.66 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_copy.py	text/plain	26.52 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_copyreg.py	text/x-script.python	4.39 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_coroutines.py	text/x-script.python	67.04 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_cprofile.py	text/plain	6.33 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_crashers.py	text/x-script.python	1.17 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_crypt.py	text/x-script.python	4.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_csv.py	text/x-script.python	59 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ctypes.py	text/x-script.python	199 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_curses.py	text/x-script.python	46.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_datetime.py	text/x-script.python	2.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dbm.py	text/plain	6.83 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dbm_dumb.py	text/plain	11.08 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dbm_gnu.py	text/x-script.python	6.82 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dbm_ndbm.py	text/x-script.python	5.46 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_decimal.py	text/plain	216.13 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_decorators.py	text/x-script.python	14.65 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_defaultdict.py	text/plain	6.13 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_deque.py	text/x-script.python	33.16 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_descr.py	text/x-script.python	195.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_descrtut.py	text/x-script.python	10.97 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_devpoll.py	text/x-script.python	4.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dict.py	text/x-script.python	50.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dict_version.py	text/plain	6.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dictcomps.py	text/x-script.python	5.15 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dictviews.py	text/x-script.python	13.69 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_difflib.py	text/x-script.python	21.47 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_difflib_expect.html	text/html	100.85 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dis.py	text/x-script.python	77.33 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_distutils.py	text/plain	549 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_docxmlrpc.py	text/x-script.python	9.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dtrace.py	text/x-script.python	7.61 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dynamic.py	text/x-script.python	5.91 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_dynamicclassattribute.py	text/x-script.python	9.57 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_eintr.py	text/x-script.python	627 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_embed.py	text/x-script.python	68.41 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ensurepip.py	text/x-script.python	12.2 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_enum.py	text/x-script.python	173.47 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_enumerate.py	text/x-script.python	9.14 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_eof.py	text/plain	3.02 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_epoll.py	text/x-script.python	9.14 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_errno.py	text/plain	1.04 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_except_star.py	text/x-script.python	38.9 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_exception_group.py	text/x-script.python	33.55 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_exception_hierarchy.py	text/x-script.python	7.54 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_exception_variations.py	text/x-script.python	13.74 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_exceptions.py	text/x-script.python	94.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_extcall.py	text/plain	14.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_faulthandler.py	text/x-script.python	30.3 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_fcntl.py	text/plain	7.43 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_file.py	text/x-script.python	11.78 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_file_eintr.py	text/x-script.python	10.74 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_filecmp.py	text/x-script.python	10.33 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_fileinput.py	text/x-script.python	37.85 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_fileio.py	text/x-script.python	19.97 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_fileutils.py	text/x-script.python	951 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_finalization.py	text/plain	14.66 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_float.py	text/x-script.python	67.84 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_flufl.py	text/plain	1.55 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_fnmatch.py	text/plain	10.68 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_fork1.py	text/plain	3.3 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_format.py	text/x-script.python	28.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_fractions.py	text/plain	34.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_frame.py	text/x-script.python	11.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_frozen.py	text/plain	2.2 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_fstring.py	text/x-script.python	53.37 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ftplib.py	text/plain	41.99 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_funcattrs.py	text/x-script.python	14.86 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_functools.py	text/x-script.python	109.04 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_gc.py	text/x-script.python	47.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_generator_stop.py	text/plain	943 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_generators.py	text/x-script.python	64.62 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_genericalias.py	text/plain	17.09 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_genericclass.py	text/x-script.python	9.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_genericpath.py	text/plain	22.29 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_genexps.py	text/x-script.python	7.3 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_getopt.py	text/x-script.python	6.59 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_getpass.py	text/x-script.python	6.37 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_getpath.py	text/x-script.python	44.37 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_gettext.py	text/x-script.python	35.67 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_glob.py	text/x-script.python	17.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_global.py	text/plain	1.2 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_grammar.py	text/x-script.python	65.51 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_graphlib.py	text/x-script.python	8.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_grp.py	text/plain	3.67 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_gzip.py	text/plain	38.78 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_hash.py	text/x-script.python	12.11 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_hashlib.py	text/x-script.python	46.51 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_heapq.py	text/plain	16.45 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_hmac.py	text/x-script.python	26.06 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_html.py	text/plain	4.23 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_htmlparser.py	text/plain	32.93 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_http_cookiejar.py	text/plain	81.59 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_http_cookies.py	text/x-script.python	20.01 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_httplib.py	text/x-script.python	89.6 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_httpservers.py	text/plain	56.13 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_idle.py	text/plain	830 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_imaplib.py	text/x-script.python	42.95 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_imghdr.py	text/x-script.python	4.81 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_imp.py	text/x-script.python	19.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_index.py	text/x-script.python	8.37 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_int.py	text/x-script.python	29.62 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_int_literal.py	text/plain	6.89 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_interpreters.py	text/x-script.python	22.57 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_io.py	text/plain	180.21 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ioctl.py	text/x-script.python	3.24 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ipaddress.py	text/x-script.python	125.61 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_isinstance.py	text/x-script.python	12.95 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_iter.py	text/x-script.python	36.77 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_iterlen.py	text/plain	7.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_itertools.py	text/x-script.python	100.18 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_keyword.py	text/x-script.python	1.97 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_keywordonlyarg.py	text/plain	6.89 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_kqueue.py	text/plain	8.76 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_largefile.py	text/plain	10.17 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_launcher.py	text/x-script.python	27.26 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_lib2to3.py	text/plain	311 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_linecache.py	text/plain	11.04 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_list.py	text/x-script.python	8.96 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_listcomps.py	text/x-script.python	3.82 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_lltrace.py	text/x-script.python	3.71 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_locale.py	text/x-script.python	25.21 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_logging.py	text/x-script.python	228.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_long.py	text/x-script.python	62 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_longexp.py	text/x-script.python	233 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_lzma.py	text/x-script.python	92.78 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_mailbox.py	text/x-script.python	92.51 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_mailcap.py	text/x-script.python	11.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_marshal.py	text/x-script.python	23.13 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_math.py	text/plain	95.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_memoryio.py	text/plain	32 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_memoryview.py	text/plain	21.37 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_metaclass.py	text/x-script.python	6.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_mimetypes.py	text/x-script.python	15.28 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_minidom.py	text/x-script.python	68.69 KB	root/linksafe	-rw-r--r--	2025-06-23 04:26:09
test_mmap.py	text/x-script.python	38.56 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_modulefinder.py	text/x-script.python	12.21 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_msilib.py	text/plain	5.52 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_multibytecodec.py	text/x-script.python	15.79 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_multiprocessing_main_handling.py	text/plain	11.37 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_named_expressions.py	text/x-script.python	21.36 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_netrc.py	text/x-script.python	11.86 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_nis.py	text/plain	1.28 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_nntplib.py	text/x-script.python	62.7 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ntpath.py	text/x-script.python	55.43 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_numeric_tower.py	text/x-script.python	8 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_opcache.py	text/x-script.python	10.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_opcodes.py	text/x-script.python	3.62 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_openpty.py	text/plain	600 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_operator.py	text/x-script.python	26.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_optparse.py	text/x-script.python	61.02 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ordered_dict.py	text/x-script.python	35.63 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_os.py	text/x-script.python	172.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ossaudiodev.py	text/x-script.python	7.27 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_osx_env.py	text/plain	1.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pathlib.py	text/x-script.python	114.88 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_patma.py	text/x-script.python	85.55 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pdb.py	text/x-script.python	81.57 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_peepholer.py	text/x-script.python	26.69 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pep646_syntax.py	text/x-script.python	7.79 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pickle.py	text/x-script.python	19.8 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_picklebuffer.py	text/plain	4.99 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pickletools.py	text/x-script.python	4.13 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pipes.py	text/x-script.python	6.79 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pkg.py	text/x-script.python	9.59 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pkgutil.py	text/x-script.python	22.84 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_platform.py	text/x-script.python	21.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_plistlib.py	text/x-script.python	41.25 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_poll.py	text/x-script.python	7.39 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_popen.py	text/plain	2.11 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_poplib.py	text/plain	17.62 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_positional_only_arg.py	text/plain	17.77 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_posix.py	text/x-script.python	93.48 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_posixpath.py	text/x-script.python	42.27 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pow.py	text/x-script.python	6.38 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pprint.py	text/x-script.python	50.58 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_print.py	text/x-ruby	7.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_profile.py	text/plain	8.69 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_property.py	text/x-script.python	12.15 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pstats.py	text/x-script.python	4.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pty.py	text/x-script.python	16.18 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pulldom.py	text/x-script.python	12.33 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pwd.py	text/x-script.python	4.32 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_py_compile.py	text/x-script.python	11.89 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pyclbr.py	text/x-script.python	10.15 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_pyexpat.py	text/x-script.python	29.34 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_queue.py	text/x-script.python	20.61 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_quopri.py	text/x-script.python	7.87 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_raise.py	text/x-script.python	13.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_random.py	text/x-script.python	55.22 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_range.py	text/x-script.python	24.64 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_re.py	text/x-script.python	132.4 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_readline.py	text/plain	12.76 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_regrtest.py	text/plain	90.02 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_repl.py	text/plain	4.99 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_reprlib.py	text/plain	15.3 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_resource.py	text/x-script.python	7.12 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_richcmp.py	text/x-script.python	11.95 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_rlcompleter.py	text/x-script.python	7.4 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_robotparser.py	text/x-script.python	11.02 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_runpy.py	text/x-script.python	33.95 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sax.py	text/x-script.python	54.63 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sched.py	text/x-script.python	7.38 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_scope.py	text/x-script.python	21.21 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_script_helper.py	text/plain	5.82 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_secrets.py	text/plain	4.28 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_select.py	text/x-script.python	3.43 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_selectors.py	text/x-script.python	19.64 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_set.py	text/x-script.python	71.3 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_setcomps.py	text/x-script.python	3.8 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_shelve.py	text/x-script.python	6.46 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_shlex.py	text/x-script.python	13.48 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_shutil.py	text/x-script.python	112.43 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_signal.py	text/x-script.python	52.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_site.py	text/plain	29.82 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_slice.py	text/x-script.python	9.23 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_smtpd.py	text/x-script.python	40.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_smtplib.py	text/x-script.python	60.1 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_smtpnet.py	text/x-script.python	3.03 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sndhdr.py	text/plain	1.51 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_socket.py	text/x-script.python	253.71 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_socketserver.py	text/plain	17.71 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sort.py	text/x-script.python	13.59 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_source_encoding.py	text/x-script.python	12.47 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_spwd.py	text/x-script.python	2.83 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ssl.py	text/x-script.python	224.97 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_stable_abi_ctypes.py	text/x-script.python	24.41 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_startfile.py	text/x-script.python	1.7 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_stat.py	text/x-script.python	8.92 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_statistics.py	text/plain	118.58 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_strftime.py	text/plain	7.54 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_string.py	text/x-script.python	21.86 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_string_literals.py	text/x-script.python	13.14 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_stringprep.py	text/plain	3.04 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_strptime.py	text/plain	36.17 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_strtod.py	text/x-script.python	20.06 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_struct.py	text/x-script.python	37.05 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_structseq.py	text/x-script.python	7.23 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_subclassinit.py	text/x-script.python	8.12 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_subprocess.py	text/x-script.python	161.6 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sunau.py	text/x-script.python	6.09 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sundry.py	text/plain	1.95 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_super.py	text/plain	9.87 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_support.py	text/x-script.python	27.42 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_symtable.py	text/plain	9.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_syntax.py	text/plain	66.33 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sys.py	text/x-script.python	66.34 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sys_setprofile.py	text/x-script.python	13.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sys_settrace.py	text/x-script.python	79.97 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_sysconfig.py	text/x-script.python	22.51 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_syslog.py	text/x-script.python	2.76 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tabnanny.py	text/plain	13.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tarfile.py	text/x-script.python	171.23 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tcl.py	text/x-script.python	27.26 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_telnetlib.py	text/x-script.python	12.85 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tempfile.py	text/x-script.python	70.35 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_termios.py	text/x-script.python	10.95 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_textwrap.py	text/x-script.python	41.89 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_thread.py	text/x-script.python	8.57 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_threadedtempfile.py	text/plain	1.93 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_threading.py	text/plain	64.25 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_threading_local.py	text/x-script.python	6.59 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_threadsignals.py	text/plain	9.87 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_time.py	text/x-script.python	42.44 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_timeit.py	text/x-script.python	15.2 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_timeout.py	text/plain	10.75 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tix.py	text/plain	1.05 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tk.py	text/plain	546 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tokenize.py	text/x-script.python	99.04 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_trace.py	text/x-script.python	20.7 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_traceback.py	text/plain	117.68 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tracemalloc.py	text/x-script.python	39.54 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ttk_guionly.py	text/plain	986 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ttk_textonly.py	text/x-script.python	16.69 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tty.py	text/plain	2.21 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_tuple.py	text/x-script.python	19.8 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_turtle.py	text/x-script.python	12.75 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_type_annotations.py	text/x-script.python	6.22 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_type_cache.py	text/plain	5.92 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_type_comments.py	text/x-script.python	10.54 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_typechecks.py	text/plain	2.55 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_types.py	text/x-script.python	77.85 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_typing.py	text/x-script.python	302 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_ucn.py	text/plain	9.52 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unary.py	text/plain	1.63 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unicode.py	text/plain	125.4 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unicode_file.py	text/x-script.python	5.72 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unicode_file_functions.py	text/x-script.python	6.91 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unicode_identifiers.py	text/x-script.python	997 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unicodedata.py	text/plain	16.26 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unittest.py	text/x-script.python	226 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_univnewlines.py	text/plain	3.88 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unpack.py	text/x-script.python	3.51 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unpack_ex.py	text/plain	9.89 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_unparse.py	text/plain	24.68 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_urllib.py	text/plain	70.12 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_urllib2.py	text/x-script.python	79 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_urllib2_localnet.py	text/x-script.python	25.59 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_urllib2net.py	text/x-script.python	13.96 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_urllib_response.py	text/plain	2 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_urllibnet.py	text/x-script.python	9.41 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_urlparse.py	text/x-script.python	78.84 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_userdict.py	text/x-script.python	7.56 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_userlist.py	text/x-script.python	1.97 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_userstring.py	text/x-script.python	2.52 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_utf8_mode.py	text/plain	10.31 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_utf8source.py	text/x-script.python	1.08 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_uu.py	text/x-ruby	9.2 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_uuid.py	text/x-script.python	40.19 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_venv.py	text/plain	35.28 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_wait3.py	text/plain	1.75 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_wait4.py	text/plain	1.15 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_wave.py	text/x-script.python	6.49 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_weakref.py	text/x-script.python	74.32 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_weakset.py	text/x-script.python	16.3 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_webbrowser.py	text/x-script.python	10.67 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_winconsoleio.py	text/x-script.python	6.69 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_winreg.py	text/x-script.python	22.2 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_winsound.py	text/x-script.python	4.61 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_with.py	text/plain	26.02 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_wsgiref.py	text/x-script.python	29.32 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_xdrlib.py	text/x-script.python	2.25 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_xml_dom_minicompat.py	text/x-script.python	4.18 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_xml_etree.py	text/x-script.python	160.54 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_xml_etree_c.py	text/x-script.python	8.73 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_xmlrpc.py	text/x-script.python	58.08 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_xmlrpc_net.py	text/x-script.python	954 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_xxlimited.py	text/x-script.python	2.46 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_xxtestfuzz.py	text/x-script.python	690 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_yield_from.py	text/x-script.python	30.09 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_zipapp.py	text/plain	16 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_zipfile.py	text/x-script.python	156.54 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_zipfile64.py	text/x-script.python	5.86 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_zipimport.py	text/x-script.python	33.87 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_zipimport_support.py	text/x-script.python	10.57 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
test_zlib.py	text/x-script.python	35.67 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
testcodec.py	text/plain	1.02 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
testtar.tar	application/x-tar	425 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
testtar.tar.xz	application/x-xz	172 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
tf_inherit_check.py	text/x-script.python	714 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
time_hashlib.py	text/x-script.python	2.87 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
win_console_handler.py	text/plain	1.38 KB	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
xmltests.py	text/x-script.python	499 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
zip_cp437_header.zip	application/zip	270 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
zipdir.zip	application/zip	374 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25
zipdir_backslash.zip	application/zip	192 B	root/linksafe	-rw-r--r--	2025-06-03 06:38:25