mirrors/RustPython
0
0 Fork 0
mirror of https://github.com/RustPython/RustPython.git synced 2026-10-28 10:44:36 +08:00
Code Activity

chore: add ruff format --check (#5774)

Browse Source 
* chore: add `ruff format --check`

* fix tests
This commit is contained in:
Rex Ledesma authored and GitHub committed 2025-05-12 14:20:01 +09:00
1 parent df380bca96
commit 4e2e0b41c6
138 files changed
+3997 -2696
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

extra_tests/benchmarks/perf_fib.py
+5 -4
View File
@@ -2,14 +2,15 @@ def fib(n):
a = 1
b = 1
for _ in range(n - 1):
temp = b
b = a + b
a = temp
temp = b
b = a + b
a = temp
return b
print(fib(1))
print(fib(2))
print(fib(3))
print(fib(4))
print(fib(5))
print(fib(5))
extra_tests/custom_text_test_runner.py
+481 -216
View File
@@ -36,10 +36,12 @@ from unittest.runner import result
from unittest.runner import registerResult
from functools import reduce
class TablePrinter(object):
# Modified from https://github.com/agramian/table-printer, same license as above
"Print a list of dicts as a table"
def __init__(self, fmt, sep='', ul=None, tl=None, bl=None):
def __init__(self, fmt, sep="", ul=None, tl=None, bl=None):
"""
@param fmt: list of tuple(heading, key, width)
heading: str, column label
@@ -50,20 +52,44 @@ class TablePrinter(object):
@param tl: string, character to draw as top line over table, or None
@param bl: string, character to draw as bottom line under table, or None
"""
super(TablePrinter,self).__init__()
fmt = [x + ('left',) if len(x) < 4 else x for x in fmt]
self.fmt = str(sep).join('{lb}{0}:{align}{1}{rb}'.format(key, width, lb='{', rb='}', align='<' if alignment == 'left' else '>') for heading,key,width,alignment in fmt)
self.head = {key:heading for heading,key,width,alignment in fmt}
self.ul = {key:str(ul)*width for heading,key,width,alignment in fmt} if ul else None
self.width = {key:width for heading,key,width,alignment in fmt}
self.tl = {key:str(tl)*width for heading,key,width,alignment in fmt} if tl else None
self.bl = {key:str(bl)*width for heading,key,width,alignment in fmt} if bl else None
super(TablePrinter, self).__init__()
fmt = [x + ("left",) if len(x) < 4 else x for x in fmt]
self.fmt = str(sep).join(
"{lb}{0}:{align}{1}{rb}".format(
key, width, lb="{", rb="}", align="<" if alignment == "left" else ">"
)
for heading, key, width, alignment in fmt
)
self.head = {key: heading for heading, key, width, alignment in fmt}
self.ul = (
{key: str(ul) * width for heading, key, width, alignment in fmt}
if ul
else None
)
self.width = {key: width for heading, key, width, alignment in fmt}
self.tl = (
{key: str(tl) * width for heading, key, width, alignment in fmt}
if tl
else None
)
self.bl = (
{key: str(bl) * width for heading, key, width, alignment in fmt}
if bl
else None
)
def row(self, data, separation_character=False):
if separation_character:
return self.fmt.format(**{ k:str(data.get(k,''))[:w] for k,w in self.width.items() })
return self.fmt.format(
**{k: str(data.get(k, ""))[:w] for k, w in self.width.items()}
)
else:
data = { k:str(data.get(k,'')) if len(str(data.get(k,''))) <= w else '%s...' %str(data.get(k,''))[:(w-3)] for k,w in self.width.items() }
data = {
k: str(data.get(k, ""))
if len(str(data.get(k, ""))) <= w
else "%s..." % str(data.get(k, ""))[: (w - 3)]
for k, w in self.width.items()
}
return self.fmt.format(**data)
def __call__(self, data_list, totals=None):
@@ -80,89 +106,111 @@ class TablePrinter(object):
res.insert(len(res), _r(totals))
if self.bl:
res.insert(len(res), _r(self.bl, True))
return '\n'.join(res)
return "\n".join(res)
def get_function_args(func_ref):
try:
return [p for p in inspect.getargspec(func_ref).args if p != 'self']
return [p for p in inspect.getargspec(func_ref).args if p != "self"]
except:
return None
def store_class_fields(class_ref, args_passed):
""" Store the passed in class fields in self
"""
"""Store the passed in class fields in self"""
params = get_function_args(class_ref.__init__)
for p in params: setattr(class_ref, p, args_passed[p])
for p in params:
setattr(class_ref, p, args_passed[p])
def sum_dict_key(d, key, cast_type=None):
""" Sum together all values matching a key given a passed dict
"""
return reduce( (lambda x, y: x + y), [eval("%s(x['%s'])" %(cast_type, key)) if cast_type else x[key] for x in d] )
"""Sum together all values matching a key given a passed dict"""
return reduce(
(lambda x, y: x + y),
[eval("%s(x['%s'])" % (cast_type, key)) if cast_type else x[key] for x in d],
)
def case_name(name):
""" Test case name decorator to override function name.
"""
"""Test case name decorator to override function name."""
def decorator(function):
function.__dict__['test_case_name'] = name
function.__dict__["test_case_name"] = name
return function
return decorator
def skip_device(name):
""" Decorator to mark a test to only run on certain devices
Takes single device name or list of names as argument
"""Decorator to mark a test to only run on certain devices
Takes single device name or list of names as argument
"""
def decorator(function):
name_list = name if type(name) == list else [name]
function.__dict__['skip_device'] = name_list
function.__dict__["skip_device"] = name_list
return function
return decorator
def _set_test_type(function, test_type):
""" Test type setter
"""
if 'test_type' in function.__dict__:
function.__dict__['test_type'].append(test_type)
"""Test type setter"""
if "test_type" in function.__dict__:
function.__dict__["test_type"].append(test_type)
else:
function.__dict__['test_type'] = [test_type]
function.__dict__["test_type"] = [test_type]
return function
def smoke(function):
""" Test decorator to mark test as smoke type
"""
return _set_test_type(function, 'smoke')
"""Test decorator to mark test as smoke type"""
return _set_test_type(function, "smoke")
def guide_discovery(function):
""" Test decorator to mark test as guide_discovery type
"""
return _set_test_type(function, 'guide_discovery')
"""Test decorator to mark test as guide_discovery type"""
return _set_test_type(function, "guide_discovery")
def focus(function):
""" Test decorator to mark test as focus type to all rspec style debugging of cases
"""
return _set_test_type(function, 'focus')
"""Test decorator to mark test as focus type to all rspec style debugging of cases"""
return _set_test_type(function, "focus")
class _WritelnDecorator(object):
"""Used to decorate file-like objects with a handy 'writeln' method"""
def __init__(self,stream):
def __init__(self, stream):
self.stream = stream
def __getattr__(self, attr):
if attr in ('stream', '__getstate__'):
if attr in ("stream", "__getstate__"):
raise AttributeError(attr)
return getattr(self.stream,attr)
return getattr(self.stream, attr)
def writeln(self, arg=None):
if arg:
self.write(arg)
self.write('\n') # text-mode streams translate to \r\n if needed
self.write("\n") # text-mode streams translate to \r\n if needed
class CustomTextTestResult(result.TestResult):
_num_formatting_chars = 150
_execution_time_significant_digits = 4
_pass_percentage_significant_digits = 2
def __init__(self, stream, descriptions, verbosity, results_file_path, result_screenshots_dir, show_previous_results, config, test_types):
def __init__(
self,
stream,
descriptions,
verbosity,
results_file_path,
result_screenshots_dir,
show_previous_results,
config,
test_types,
):
super(CustomTextTestResult, self).__init__(stream, descriptions, verbosity)
store_class_fields(self, locals())
self.show_overall_results = verbosity > 0
@@ -178,12 +226,12 @@ class CustomTextTestResult(result.TestResult):
self.separator3 = "_" * CustomTextTestResult._num_formatting_chars
self.separator4 = "*" * CustomTextTestResult._num_formatting_chars
self.separator_failure = "!" * CustomTextTestResult._num_formatting_chars
self.separator_pre_result = '.' * CustomTextTestResult._num_formatting_chars
self.separator_pre_result = "." * CustomTextTestResult._num_formatting_chars
def getDescription(self, test):
doc_first_line = test.shortDescription()
if self.descriptions and doc_first_line:
return '\n'.join((str(test), doc_first_line))
return "\n".join((str(test), doc_first_line))
else:
return str(test)
@@ -195,109 +243,170 @@ class CustomTextTestResult(result.TestResult):
self.results = None
self.previous_suite_runs = []
if os.path.isfile(self.results_file_path):
with open(self.results_file_path, 'rb') as f:
with open(self.results_file_path, "rb") as f:
try:
self.results = json.load(f)
# recreated results dict with int keys
self.results['suites'] = {int(k):v for (k,v) in list(self.results['suites'].items())}
self.suite_map = {v['name']:int(k) for (k,v) in list(self.results['suites'].items())}
self.previous_suite_runs = list(self.results['suites'].keys())
self.results["suites"] = {
int(k): v for (k, v) in list(self.results["suites"].items())
}
self.suite_map = {
v["name"]: int(k)
for (k, v) in list(self.results["suites"].items())
}
self.previous_suite_runs = list(self.results["suites"].keys())
except:
pass
if not self.results:
self.results = {'suites': {},
'name': '',
'num_passed': 0,
'num_failed': 0,
'num_skipped': 0,
'num_expected_failures': 0,
'execution_time': None}
self.suite_number = int(sorted(self.results['suites'].keys())[-1]) + 1 if len(self.results['suites']) else 0
self.results = {
"suites": {},
"name": "",
"num_passed": 0,
"num_failed": 0,
"num_skipped": 0,
"num_expected_failures": 0,
"execution_time": None,
}
self.suite_number = (
int(sorted(self.results["suites"].keys())[-1]) + 1
if len(self.results["suites"])
else 0
)
self.case_number = 0
self.suite_map = {}
def stopTestRun(self):
# if no tests or some failure occurred execution time may not have been set
try:
self.results['suites'][self.suite_map[self.suite]]['execution_time'] = format(self.suite_execution_time, '.%sf' %CustomTextTestResult._execution_time_significant_digits)
self.results["suites"][self.suite_map[self.suite]]["execution_time"] = (
format(
self.suite_execution_time,
".%sf" % CustomTextTestResult._execution_time_significant_digits,
)
)
except:
pass
self.results['execution_time'] = format(self.total_execution_time, '.%sf' %CustomTextTestResult._execution_time_significant_digits)
self.results["execution_time"] = format(
self.total_execution_time,
".%sf" % CustomTextTestResult._execution_time_significant_digits,
)
self.stream.writeln(self.separator3)
with open(self.results_file_path, 'w') as f:
with open(self.results_file_path, "w") as f:
json.dump(self.results, f)
def startTest(self, test):
suite_base_category = test.__class__.base_test_category if hasattr(test.__class__, 'base_test_category') else ''
self.next_suite = os.path.join(suite_base_category, test.__class__.name if hasattr(test.__class__, 'name') else test.__class__.__name__)
suite_base_category = (
test.__class__.base_test_category
if hasattr(test.__class__, "base_test_category")
else ""
)
self.next_suite = os.path.join(
suite_base_category,
test.__class__.name
if hasattr(test.__class__, "name")
else test.__class__.__name__,
)
self.case = test._testMethodName
super(CustomTextTestResult, self).startTest(test)
if not self.suite or self.suite != self.next_suite:
if self.suite:
self.results['suites'][self.suite_map[self.suite]]['execution_time'] = format(self.suite_execution_time, '.%sf' %CustomTextTestResult._execution_time_significant_digits)
self.results["suites"][self.suite_map[self.suite]]["execution_time"] = (
format(
self.suite_execution_time,
".%sf"
% CustomTextTestResult._execution_time_significant_digits,
)
)
self.suite_execution_time = 0
self.suite = self.next_suite
if self.show_test_info:
self.stream.writeln(self.separator1)
self.stream.writeln("TEST SUITE: %s" %self.suite)
self.stream.writeln("Description: %s" %self.getSuiteDescription(test))
self.stream.writeln("TEST SUITE: %s" % self.suite)
self.stream.writeln("Description: %s" % self.getSuiteDescription(test))
try:
name_override = getattr(test, test._testMethodName).__func__.__dict__['test_case_name']
name_override = getattr(test, test._testMethodName).__func__.__dict__[
"test_case_name"
]
except:
name_override = None
self.case = name_override if name_override else self.case
if self.show_test_info:
# self.stream.writeln(self.separator2)
self.stream.write("CASE: %s" %self.case)
if desc := test.shortDescription(): self.stream.write(" (Description: %s)" % desc)
self.stream.write("CASE: %s" % self.case)
if desc := test.shortDescription():
self.stream.write(" (Description: %s)" % desc)
self.stream.write("... ")
# self.stream.writeln(self.separator2)
self.stream.flush()
self.current_case_number = self.case_number
if self.suite not in self.suite_map:
self.suite_map[self.suite] = self.suite_number
self.results['suites'][self.suite_number] = {
'name': self.suite,
'class': test.__class__.__name__,
'module': re.compile('.* \((.*)\)').match(str(test)).group(1),
'description': self.getSuiteDescription(test),
'cases': {},
'used_case_names': {},
'num_passed': 0,
'num_failed': 0,
'num_skipped': 0,
'num_expected_failures': 0,
'execution_time': None}
self.results["suites"][self.suite_number] = {
"name": self.suite,
"class": test.__class__.__name__,
"module": re.compile(".* \((.*)\)").match(str(test)).group(1),
"description": self.getSuiteDescription(test),
"cases": {},
"used_case_names": {},
"num_passed": 0,
"num_failed": 0,
"num_skipped": 0,
"num_expected_failures": 0,
"execution_time": None,
}
self.suite_number += 1
self.num_cases = 0
self.num_passed = 0
self.num_failed = 0
self.num_skipped = 0
self.num_expected_failures = 0
self.results['suites'][self.suite_map[self.suite]]['cases'][self.case_number] = {
'name': self.case,
'method': test._testMethodName,
'result': None,
'description': test.shortDescription(),
'note': None,
'errors': None,
'failures': None,
'screenshots': [],
'new_version': 'No',
'execution_time': None}
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.case_number
] = {
"name": self.case,
"method": test._testMethodName,
"result": None,
"description": test.shortDescription(),
"note": None,
"errors": None,
"failures": None,
"screenshots": [],
"new_version": "No",
"execution_time": None,
}
self.start_time = time.time()
if self.test_types:
if ('test_type' in getattr(test, test._testMethodName).__func__.__dict__
and set([s.lower() for s in self.test_types]) == set([s.lower() for s in getattr(test, test._testMethodName).__func__.__dict__['test_type']])):
if "test_type" in getattr(
test, test._testMethodName
).__func__.__dict__ and set([s.lower() for s in self.test_types]) == set(
[
s.lower()
for s in getattr(test, test._testMethodName).__func__.__dict__[
"test_type"
]
]
):
pass
else:
getattr(test, test._testMethodName).__func__.__dict__['__unittest_skip_why__'] = 'Test run specified to only run tests of type "%s"' %','.join(self.test_types)
getattr(test, test._testMethodName).__func__.__dict__['__unittest_skip__'] = True
if 'skip_device' in getattr(test, test._testMethodName).__func__.__dict__:
for device in getattr(test, test._testMethodName).__func__.__dict__['skip_device']:
if self.config and device.lower() in self.config['device_name'].lower():
getattr(test, test._testMethodName).__func__.__dict__['__unittest_skip_why__'] = 'Test is marked to be skipped on %s' %device
getattr(test, test._testMethodName).__func__.__dict__['__unittest_skip__'] = True
getattr(test, test._testMethodName).__func__.__dict__[
"__unittest_skip_why__"
] = 'Test run specified to only run tests of type "%s"' % ",".join(
self.test_types
)
getattr(test, test._testMethodName).__func__.__dict__[
"__unittest_skip__"
] = True
if "skip_device" in getattr(test, test._testMethodName).__func__.__dict__:
for device in getattr(test, test._testMethodName).__func__.__dict__[
"skip_device"
]:
if self.config and device.lower() in self.config["device_name"].lower():
getattr(test, test._testMethodName).__func__.__dict__[
"__unittest_skip_why__"
] = "Test is marked to be skipped on %s" % device
getattr(test, test._testMethodName).__func__.__dict__[
"__unittest_skip__"
] = True
break
def stopTest(self, test):
@@ -307,19 +416,32 @@ class CustomTextTestResult(result.TestResult):
self.total_execution_time += self.execution_time
super(CustomTextTestResult, self).stopTest(test)
self.num_cases += 1
self.results['suites'][self.suite_map[self.suite]]['num_passed'] = self.num_passed
self.results['suites'][self.suite_map[self.suite]]['num_failed'] = self.num_failed
self.results['suites'][self.suite_map[self.suite]]['num_skipped'] = self.num_skipped
self.results['suites'][self.suite_map[self.suite]]['num_expected_failures'] = self.num_expected_failures
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['execution_time']= format(self.execution_time, '.%sf' %CustomTextTestResult._execution_time_significant_digits)
self.results['num_passed'] += self.num_passed
self.results['num_failed'] += self.num_failed
self.results['num_skipped'] += self.num_skipped
self.results['num_expected_failures'] += self.num_expected_failures
self.results["suites"][self.suite_map[self.suite]]["num_passed"] = (
self.num_passed
)
self.results["suites"][self.suite_map[self.suite]]["num_failed"] = (
self.num_failed
)
self.results["suites"][self.suite_map[self.suite]]["num_skipped"] = (
self.num_skipped
)
self.results["suites"][self.suite_map[self.suite]]["num_expected_failures"] = (
self.num_expected_failures
)
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["execution_time"] = format(
self.execution_time,
".%sf" % CustomTextTestResult._execution_time_significant_digits,
)
self.results["num_passed"] += self.num_passed
self.results["num_failed"] += self.num_failed
self.results["num_skipped"] += self.num_skipped
self.results["num_expected_failures"] += self.num_expected_failures
self.case_number += 1
def print_error_string(self, err):
error_string = ''.join(traceback.format_exception(err[0], err[1], err[2]))
error_string = "".join(traceback.format_exception(err[0], err[1], err[2]))
if self.show_errors:
self.stream.writeln(self.separator_failure)
self.stream.write(error_string)
@@ -328,7 +450,9 @@ class CustomTextTestResult(result.TestResult):
def addScreenshots(self, test):
for root, dirs, files in os.walk(self.result_screenshots_dir):
for file in files:
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['screenshots'].append(os.path.join(root, file))
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["screenshots"].append(os.path.join(root, file))
def addSuccess(self, test):
super(CustomTextTestResult, self).addSuccess(test)
@@ -336,7 +460,9 @@ class CustomTextTestResult(result.TestResult):
# self.stream.writeln(self.separator_pre_result)
self.stream.writeln("PASS")
self.stream.flush()
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['result'] = 'passed'
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["result"] = "passed"
self.num_passed += 1
self.addScreenshots(test)
@@ -347,8 +473,12 @@ class CustomTextTestResult(result.TestResult):
# self.stream.writeln(self.separator_pre_result)
self.stream.writeln("ERROR")
self.stream.flush()
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['result'] = 'error'
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['errors'] = error_string
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["result"] = "error"
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["errors"] = error_string
self.num_failed += 1
self.addScreenshots(test)
@@ -359,8 +489,12 @@ class CustomTextTestResult(result.TestResult):
# self.stream.writeln(self.separator_pre_result)
self.stream.writeln("FAIL")
self.stream.flush()
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['result'] = 'failed'
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['failures'] = error_string
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["result"] = "failed"
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["failures"] = error_string
self.num_failed += 1
self.addScreenshots(test)
@@ -370,8 +504,12 @@ class CustomTextTestResult(result.TestResult):
# self.stream.writeln(self.separator_pre_result)
self.stream.writeln("SKIPPED {0!r}".format(reason))
self.stream.flush()
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['result'] = 'skipped'
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['note'] = reason
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["result"] = "skipped"
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["note"] = reason
self.num_skipped += 1
def addExpectedFailure(self, test, err):
@@ -380,7 +518,9 @@ class CustomTextTestResult(result.TestResult):
# self.stream.writeln(self.separator_pre_result)
self.stream.writeln("EXPECTED FAILURE")
self.stream.flush()
self.results['suites'][self.suite_map[self.suite]]['cases'][self.current_case_number]['result'] = 'expected_failure'
self.results["suites"][self.suite_map[self.suite]]["cases"][
self.current_case_number
]["result"] = "expected_failure"
self.num_expected_failures += 1
self.addScreenshots(test)
@@ -396,103 +536,189 @@ class CustomTextTestResult(result.TestResult):
def printOverallSuiteResults(self, r):
self.stream.writeln()
self.stream.writeln(self.separator4)
self.stream.writeln('OVERALL SUITE RESULTS')
self.stream.writeln("OVERALL SUITE RESULTS")
fmt = [
('SUITE', 'suite', 50, 'left'),
('CASES', 'cases', 15, 'right'),
('PASSED', 'passed', 15, 'right'),
('FAILED', 'failed', 15, 'right'),
('SKIPPED', 'skipped', 15, 'right'),
('%', 'percentage', 20, 'right'),
('TIME (s)', 'time', 20, 'right')
("SUITE", "suite", 50, "left"),
("CASES", "cases", 15, "right"),
("PASSED", "passed", 15, "right"),
("FAILED", "failed", 15, "right"),
("SKIPPED", "skipped", 15, "right"),
("%", "percentage", 20, "right"),
("TIME (s)", "time", 20, "right"),
]
data = []
for x in r: data.append({'suite': r[x]['name'],
'cases': r[x]['num_passed'] + r[x]['num_failed'],
'passed': r[x]['num_passed'],
'failed': r[x]['num_failed'],
'skipped': r[x]['num_skipped'],
'expected_failures': r[x]['num_expected_failures'],
'percentage': float(r[x]['num_passed'])/(r[x]['num_passed'] + r[x]['num_failed']) * 100 if (r[x]['num_passed'] + r[x]['num_failed']) > 0 else 0,
'time': r[x]['execution_time']})
total_suites_passed = len([x for x in data if not x['failed']])
total_suites_passed_percentage = format(float(total_suites_passed)/len(data) * 100, '.%sf' %CustomTextTestResult._pass_percentage_significant_digits)
totals = {'suite': 'TOTALS %s/%s (%s%%) suites passed' %(total_suites_passed, len(data), total_suites_passed_percentage),
'cases': sum_dict_key(data, 'cases'),
'passed': sum_dict_key(data, 'passed'),
'failed': sum_dict_key(data, 'failed'),
'skipped': sum_dict_key(data, 'skipped'),
'percentage': sum_dict_key(data, 'percentage')/len(data),
'time': sum_dict_key(data, 'time', 'float')}
for x in data: operator.setitem(x, 'percentage', format(x['percentage'], '.%sf' %CustomTextTestResult._pass_percentage_significant_digits))
totals['percentage'] = format(totals['percentage'], '.%sf' %CustomTextTestResult._pass_percentage_significant_digits)
self.stream.writeln( TablePrinter(fmt, tl=self.separator1, ul=self.separator2, bl=self.separator3)(data, totals) )
for x in r:
data.append(
{
"suite": r[x]["name"],
"cases": r[x]["num_passed"] + r[x]["num_failed"],
"passed": r[x]["num_passed"],
"failed": r[x]["num_failed"],
"skipped": r[x]["num_skipped"],
"expected_failures": r[x]["num_expected_failures"],
"percentage": float(r[x]["num_passed"])
/ (r[x]["num_passed"] + r[x]["num_failed"])
* 100
if (r[x]["num_passed"] + r[x]["num_failed"]) > 0
else 0,
"time": r[x]["execution_time"],
}
)
total_suites_passed = len([x for x in data if not x["failed"]])
total_suites_passed_percentage = format(
float(total_suites_passed) / len(data) * 100,
".%sf" % CustomTextTestResult._pass_percentage_significant_digits,
)
totals = {
"suite": "TOTALS %s/%s (%s%%) suites passed"
% (total_suites_passed, len(data), total_suites_passed_percentage),
"cases": sum_dict_key(data, "cases"),
"passed": sum_dict_key(data, "passed"),
"failed": sum_dict_key(data, "failed"),
"skipped": sum_dict_key(data, "skipped"),
"percentage": sum_dict_key(data, "percentage") / len(data),
"time": sum_dict_key(data, "time", "float"),
}
for x in data:
operator.setitem(
x,
"percentage",
format(
x["percentage"],
".%sf" % CustomTextTestResult._pass_percentage_significant_digits,
),
)
totals["percentage"] = format(
totals["percentage"],
".%sf" % CustomTextTestResult._pass_percentage_significant_digits,
)
self.stream.writeln(
TablePrinter(
fmt, tl=self.separator1, ul=self.separator2, bl=self.separator3
)(data, totals)
)
self.stream.writeln()
def printIndividualSuiteResults(self, r):
self.stream.writeln()
self.stream.writeln(self.separator4)
self.stream.writeln('INDIVIDUAL SUITE RESULTS')
self.stream.writeln("INDIVIDUAL SUITE RESULTS")
fmt = [
('CASE', 'case', 50, 'left'),
('DESCRIPTION', 'description', 50, 'right'),
('RESULT', 'result', 25, 'right'),
('TIME (s)', 'time', 25, 'right')
("CASE", "case", 50, "left"),
("DESCRIPTION", "description", 50, "right"),
("RESULT", "result", 25, "right"),
("TIME (s)", "time", 25, "right"),
]
for suite in r:
self.stream.writeln(self.separator1)
self.stream.write('{0: <50}'.format('SUITE: %s' %r[suite]['name']))
self.stream.writeln('{0: <100}'.format('DESCRIPTION: %s' %(r[suite]['description'] if not r[suite]['description'] or len(r[suite]['description']) <= (100 - len('DESCRIPTION: '))
else '%s...' %r[suite]['description'][:(97 - len('DESCRIPTION: '))])))
self.stream.write("{0: <50}".format("SUITE: %s" % r[suite]["name"]))
self.stream.writeln(
"{0: <100}".format(
"DESCRIPTION: %s"
% (
r[suite]["description"]
if not r[suite]["description"]
or len(r[suite]["description"]) <= (100 - len("DESCRIPTION: "))
else "%s..."
% r[suite]["description"][: (97 - len("DESCRIPTION: "))]
)
)
)
data = []
cases = r[suite]['cases']
for x in cases: data.append({'case': cases[x]['name'],
'description': cases[x]['description'],
'result': cases[x]['result'].upper() if cases[x]['result'] else cases[x]['result'],
'time': cases[x]['execution_time']})
self.stream.writeln( TablePrinter(fmt, tl=self.separator1, ul=self.separator2)(data) )
cases = r[suite]["cases"]
for x in cases:
data.append(
{
"case": cases[x]["name"],
"description": cases[x]["description"],
"result": cases[x]["result"].upper()
if cases[x]["result"]
else cases[x]["result"],
"time": cases[x]["execution_time"],
}
)
self.stream.writeln(
TablePrinter(fmt, tl=self.separator1, ul=self.separator2)(data)
)
self.stream.writeln(self.separator3)
self.stream.writeln()
def printErrorsOverview(self, r):
self.stream.writeln()
self.stream.writeln(self.separator4)
self.stream.writeln('FAILURES AND ERRORS OVERVIEW')
self.stream.writeln("FAILURES AND ERRORS OVERVIEW")
fmt = [
('SUITE', 'suite', 50, 'left'),
('CASE', 'case', 50, 'left'),
('RESULT', 'result', 50, 'right')
("SUITE", "suite", 50, "left"),
("CASE", "case", 50, "left"),
("RESULT", "result", 50, "right"),
]
data = []
for suite in r:
cases = {k:v for (k,v) in list(r[suite]['cases'].items()) if v['failures'] or v['errors']}
for x in cases: data.append({'suite': '%s%s' %(r[suite]['name'], ' (%s)' %r[suite]['module'] if r[suite]['class'] != r[suite]['name'] else ''),
'case': '%s%s' %(cases[x]['name'], ' (%s)' %cases[x]['method'] if cases[x]['name'] != cases[x]['method'] else ''),
'result': cases[x]['result'].upper()})
self.stream.writeln( TablePrinter(fmt, tl=self.separator1, ul=self.separator2)(data) )
cases = {
k: v
for (k, v) in list(r[suite]["cases"].items())
if v["failures"] or v["errors"]
}
for x in cases:
data.append(
{
"suite": "%s%s"
% (
r[suite]["name"],
" (%s)" % r[suite]["module"]
if r[suite]["class"] != r[suite]["name"]
else "",
),
"case": "%s%s"
% (
cases[x]["name"],
" (%s)" % cases[x]["method"]
if cases[x]["name"] != cases[x]["method"]
else "",
),
"result": cases[x]["result"].upper(),
}
)
self.stream.writeln(
TablePrinter(fmt, tl=self.separator1, ul=self.separator2)(data)
)
self.stream.writeln(self.separator3)
self.stream.writeln()
def printErrorsDetail(self, r):
self.stream.writeln()
self.stream.writeln(self.separator4)
self.stream.writeln('FAILURES AND ERRORS DETAIL')
self.stream.writeln("FAILURES AND ERRORS DETAIL")
for suite in r:
failures_and_errors = [k for (k,v) in list(r[suite]['cases'].items()) if v['failures'] or v['errors']]
#print failures_and_errors
suite_str = '%s%s' %(r[suite]['name'], ' (%s)' %r[suite]['module'] if r[suite]['class'] != r[suite]['name'] else '')
failures_and_errors = [
k
for (k, v) in list(r[suite]["cases"].items())
if v["failures"] or v["errors"]
]
# print failures_and_errors
suite_str = "%s%s" % (
r[suite]["name"],
" (%s)" % r[suite]["module"]
if r[suite]["class"] != r[suite]["name"]
else "",
)
for case in failures_and_errors:
case_ref = r[suite]['cases'][case]
case_str = '%s%s' %(case_ref['name'], ' (%s)' %case_ref['method'] if case_ref['name'] != case_ref['method'] else '')
errors = case_ref['errors']
failures = case_ref['failures']
case_ref = r[suite]["cases"][case]
case_str = "%s%s" % (
case_ref["name"],
" (%s)" % case_ref["method"]
if case_ref["name"] != case_ref["method"]
else "",
)
errors = case_ref["errors"]
failures = case_ref["failures"]
self.stream.writeln(self.separator1)
if errors:
self.stream.writeln('ERROR: %s [%s]' %(case_str, suite_str))
self.stream.writeln("ERROR: %s [%s]" % (case_str, suite_str))
self.stream.writeln(self.separator2)
self.stream.writeln(errors)
if failures:
self.stream.writeln('FAILURE: %s [%s]' %(case_str, suite_str))
self.stream.writeln("FAILURE: %s [%s]" % (case_str, suite_str))
self.stream.writeln(self.separator2)
self.stream.writeln(failures)
self.stream.writeln(self.separator3)
@@ -501,52 +727,85 @@ class CustomTextTestResult(result.TestResult):
def printSkippedDetail(self, r):
self.stream.writeln()
self.stream.writeln(self.separator4)
self.stream.writeln('SKIPPED DETAIL')
self.stream.writeln("SKIPPED DETAIL")
fmt = [
('SUITE', 'suite', 50, 'left'),
('CASE', 'case', 50, 'left'),
('REASON', 'reason', 50, 'right')
("SUITE", "suite", 50, "left"),
("CASE", "case", 50, "left"),
("REASON", "reason", 50, "right"),
]
data = []
for suite in r:
cases = {k:v for (k,v) in list(r[suite]['cases'].items()) if v['result'] == 'skipped'}
for x in cases: data.append({'suite': '%s%s' %(r[suite]['name'], ' (%s)' %r[suite]['module'] if r[suite]['class'] != r[suite]['name'] else ''),
'case': '%s%s' %(cases[x]['name'], ' (%s)' %cases[x]['method'] if cases[x]['name'] != cases[x]['method'] else ''),
'reason': cases[x]['note']})
self.stream.writeln( TablePrinter(fmt, tl=self.separator1, ul=self.separator2)(data) )
cases = {
k: v
for (k, v) in list(r[suite]["cases"].items())
if v["result"] == "skipped"
}
for x in cases:
data.append(
{
"suite": "%s%s"
% (
r[suite]["name"],
" (%s)" % r[suite]["module"]
if r[suite]["class"] != r[suite]["name"]
else "",
),
"case": "%s%s"
% (
cases[x]["name"],
" (%s)" % cases[x]["method"]
if cases[x]["name"] != cases[x]["method"]
else "",
),
"reason": cases[x]["note"],
}
)
self.stream.writeln(
TablePrinter(fmt, tl=self.separator1, ul=self.separator2)(data)
)
self.stream.writeln(self.separator3)
self.stream.writeln()
def returnCode(self):
return not self.wasSuccessful()
class CustomTextTestRunner(unittest.TextTestRunner):
"""A test runner class that displays results in textual form.
It prints out the names of tests as they are run, errors as they
occur, and a summary of the results at the end of the test run.
"""
def __init__(self,
stream=sys.stderr,
descriptions=True,
verbosity=1,
failfast=False,
buffer=False,
resultclass=CustomTextTestResult,
results_file_path="results.json",
result_screenshots_dir='',
show_previous_results=False,
test_name=None,
test_description=None,
config=None,
test_types=None):
def __init__(
self,
stream=sys.stderr,
descriptions=True,
verbosity=1,
failfast=False,
buffer=False,
resultclass=CustomTextTestResult,
results_file_path="results.json",
result_screenshots_dir="",
show_previous_results=False,
test_name=None,
test_description=None,
config=None,
test_types=None,
):
store_class_fields(self, locals())
self.stream = _WritelnDecorator(stream)
def _makeResult(self):
return self.resultclass(self.stream, self.descriptions, self.verbosity,
self.results_file_path, self.result_screenshots_dir, self.show_previous_results,
self.config, self.test_types)
return self.resultclass(
self.stream,
self.descriptions,
self.verbosity,
self.results_file_path,
self.result_screenshots_dir,
self.show_previous_results,
self.config,
self.test_types,
)
def run(self, test):
output = ""
@@ -556,22 +815,26 @@ class CustomTextTestRunner(unittest.TextTestRunner):
result.failfast = self.failfast
result.buffer = self.buffer
startTime = time.time()
startTestRun = getattr(result, 'startTestRun', None)
startTestRun = getattr(result, "startTestRun", None)
if startTestRun is not None:
startTestRun()
try:
test(result)
finally:
stopTestRun = getattr(result, 'stopTestRun', None)
stopTestRun = getattr(result, "stopTestRun", None)
if stopTestRun is not None:
stopTestRun()
stopTime = time.time()
timeTaken = stopTime - startTime
# filter results to output
if result.show_previous_results:
r = result.results['suites']
r = result.results["suites"]
else:
r = {k:v for (k,v) in list(result.results['suites'].items()) if k not in result.previous_suite_runs}
r = {
k: v
for (k, v) in list(result.results["suites"].items())
if k not in result.previous_suite_runs
}
# print results based on verbosity
if result.show_all:
result.printSkippedDetail(r)
@@ -584,15 +847,17 @@ class CustomTextTestRunner(unittest.TextTestRunner):
if result.show_overall_results:
result.printOverallSuiteResults(r)
run = result.testsRun
self.stream.writeln("Ran %d test case%s in %.4fs" %
(run, run != 1 and "s" or "", timeTaken))
self.stream.writeln(
"Ran %d test case%s in %.4fs" % (run, run != 1 and "s" or "", timeTaken)
)
self.stream.writeln()
expectedFails = unexpectedSuccesses = skipped = 0
try:
results = map(len, (result.expectedFailures,
result.unexpectedSuccesses,
result.skipped))
results = map(
len,
(result.expectedFailures, result.unexpectedSuccesses, result.skipped),
)
except AttributeError:
pass
else:
extra_tests/jsontests.py
+8 -3
View File
@@ -6,8 +6,9 @@ import os
testnames = findtests()
# idk why this fixes the hanging, if it does
testnames.remove('test_importlib')
testnames.insert(0, 'test_importlib')
testnames.remove("test_importlib")
testnames.insert(0, "test_importlib")
def loadTestsOrSkip(loader, name):
try:
@@ -17,12 +18,16 @@ def loadTestsOrSkip(loader, name):
@unittest.skip(str(exc))
def testSkipped(self):
pass
attrs = {name: testSkipped}
TestClass = type("ModuleSkipped", (unittest.TestCase,), attrs)
return loader.suiteClass((TestClass(name),))
loader = unittest.defaultTestLoader
suite = loader.suiteClass([loadTestsOrSkip(loader, 'test.' + name) for name in testnames])
suite = loader.suiteClass(
[loadTestsOrSkip(loader, "test." + name) for name in testnames]
)
resultsfile = os.path.join(os.path.dirname(__file__), "cpython_tests_results.json")
if os.path.exists(resultsfile):
extra_tests/snippets/3.1.3.4.py
+2 -3
View File
@@ -1,3 +1,2 @@
l = [1,2,3]
assert [1,2,3,4,5] == (l + [4,5])
l = [1, 2, 3]
assert [1, 2, 3, 4, 5] == (l + [4, 5])
extra_tests/snippets/3.1.3.5.py
+2 -2
View File
@@ -1,3 +1,3 @@
x = [1,999,3]
x = [1, 999, 3]
x[1] = 2
assert [1,2,3] == x
assert [1, 2, 3] == x
extra_tests/snippets/builtin_abs.py
-1
View File
@@ -2,4 +2,3 @@ assert abs(-3) == 3
assert abs(7) == 7
assert abs(-3.21) == 3.21
assert abs(6.25) == 6.25
extra_tests/snippets/builtin_ascii.py
+5 -5
View File
@@ -1,7 +1,7 @@
assert ascii('hello world') == "'hello world'"
assert ascii('안녕 세상') == "'\\uc548\\ub155 \\uc138\\uc0c1'"
assert ascii('안녕 RustPython') == "'\\uc548\\ub155 RustPython'"
assert ascii(5) == '5'
assert ascii("hello world") == "'hello world'"
assert ascii("안녕 세상") == "'\\uc548\\ub155 \\uc138\\uc0c1'"
assert ascii("안녕 RustPython") == "'\\uc548\\ub155 RustPython'"
assert ascii(5) == "5"
assert ascii(chr(0x10001)) == "'\\U00010001'"
assert ascii(chr(0x9999)) == "'\\u9999'"
assert ascii(chr(0x0A)) == "'\\n'"
assert ascii(chr(0x0A)) == "'\\n'"
extra_tests/snippets/builtin_bin.py
+12 -12
View File
@@ -1,13 +1,13 @@
assert bin(0) == '0b0'
assert bin(1) == '0b1'
assert bin(-1) == '-0b1'
assert bin(2**24) == '0b1' + '0' * 24
assert bin(2**24-1) == '0b' + '1' * 24
assert bin(-(2**24)) == '-0b1' + '0' * 24
assert bin(-(2**24-1)) == '-0b' + '1' * 24
assert bin(0) == "0b0"
assert bin(1) == "0b1"
assert bin(-1) == "-0b1"
assert bin(2**24) == "0b1" + "0" * 24
assert bin(2**24 - 1) == "0b" + "1" * 24
assert bin(-(2**24)) == "-0b1" + "0" * 24
assert bin(-(2**24 - 1)) == "-0b" + "1" * 24
a = 2 ** 65
assert bin(a) == '0b1' + '0' * 65
assert bin(a-1) == '0b' + '1' * 65
assert bin(-(a)) == '-0b1' + '0' * 65
assert bin(-(a-1)) == '-0b' + '1' * 65
a = 2**65
assert bin(a) == "0b1" + "0" * 65
assert bin(a - 1) == "0b" + "1" * 65
assert bin(-(a)) == "-0b1" + "0" * 65
assert bin(-(a - 1)) == "-0b" + "1" * 65
extra_tests/snippets/builtin_bool.py
+27 -4
View File
@@ -30,18 +30,20 @@ if not {} and not [1]:
if not object():
raise BaseException
class Falsey:
def __bool__(self):
return False
assert not Falsey()
assert (True or fake) # noqa: F821
assert (False or True)
assert True or fake # noqa: F821
assert False or True
assert not (False or False)
assert ("thing" or 0) == "thing"
assert (True and True)
assert True and True
assert not (False and fake) # noqa: F821
assert (True and 5) == 5
@@ -92,15 +94,17 @@ assert bool(set()) is False
assert bool({"key": "value"}) is True
assert bool([1]) is True
assert bool(set([1,2])) is True
assert bool(set([1, 2])) is True
assert repr(True) == "True"
# Check __len__ work
class TestMagicMethodLenZero:
def __len__(self):
return 0
class TestMagicMethodLenOne:
def __len__(self):
return 1
@@ -118,6 +122,7 @@ class TestMagicMethodBoolTrueLenFalse:
def __len__(self):
return 0
class TestMagicMethodBoolFalseLenTrue:
def __bool__(self):
return False
@@ -125,6 +130,7 @@ class TestMagicMethodBoolFalseLenTrue:
def __len__(self):
return 1
assert bool(TestMagicMethodBoolTrueLenFalse()) is True
assert bool(TestMagicMethodBoolFalseLenTrue()) is False
@@ -134,9 +140,11 @@ class TestBoolThrowError:
def __bool__(self):
return object()
with assert_raises(TypeError):
bool(TestBoolThrowError())
class TestLenThrowError:
def __len__(self):
return object()
@@ -145,6 +153,7 @@ class TestLenThrowError:
with assert_raises(TypeError):
bool(TestLenThrowError())
# Verify that TypeError occurs when bad things are returned
# from __bool__(). This isn't really a bool test, but
# it's related.
@@ -152,31 +161,45 @@ def check(o):
with assert_raises(TypeError):
bool(o)
class Foo(object):
def __bool__(self):
return self
check(Foo())
class Bar(object):
def __bool__(self):
return "Yes"
check(Bar())
class Baz(int):
def __bool__(self):
return self
check(Baz())
# __bool__() must return a bool not an int
class Spam(int):
def __bool__(self):
return 1
check(Spam())
class Eggs:
def __len__(self):
return -1
with assert_raises(ValueError):
bool(Eggs())
extra_tests/snippets/builtin_bytearray.py
+154 -67
View File
@@ -40,9 +40,11 @@ assert (
)
assert repr(bytearray(b"abcd")) == "bytearray(b'abcd')"
class B(bytearray):
pass
assert repr(B()) == "B(b'')"
assert (
repr(B([0, 1, 9, 10, 11, 13, 31, 32, 33, 89, 120, 255]))
@@ -283,9 +285,9 @@ assert bytearray(b"").join(
) == bytearray(b"jiljlkmoomkaaaa")
with assert_raises(TypeError):
bytearray(b"").join((b"km", "kl"))
assert bytearray(b"abc").join((
bytearray(b"123"), bytearray(b"xyz")
)) == bytearray(b"123abcxyz")
assert bytearray(b"abc").join((bytearray(b"123"), bytearray(b"xyz"))) == bytearray(
b"123abcxyz"
)
# endswith startswith
@@ -372,16 +374,45 @@ assert bytearray(b" spacious \n ").rstrip() == bytearray(b" spacious")
assert bytearray(b"mississippi").rstrip(b"ipz") == bytearray(b"mississ")
# split
assert bytearray(b"1,2,3").split(bytearray(b",")) == [bytearray(b"1"), bytearray(b"2"), bytearray(b"3")]
assert bytearray(b"1,2,3").split(bytearray(b","), maxsplit=1) == [bytearray(b"1"), bytearray(b"2,3")]
assert bytearray(b"1,2,,3,").split(bytearray(b",")) == [bytearray(b"1"), bytearray(b"2"), bytearray(b""), bytearray(b"3"), bytearray(b"")]
assert bytearray(b"1 2 3").split() == [bytearray(b"1"), bytearray(b"2"), bytearray(b"3")]
assert bytearray(b"1,2,3").split(bytearray(b",")) == [
bytearray(b"1"),
bytearray(b"2"),
bytearray(b"3"),
]
assert bytearray(b"1,2,3").split(bytearray(b","), maxsplit=1) == [
bytearray(b"1"),
bytearray(b"2,3"),
]
assert bytearray(b"1,2,,3,").split(bytearray(b",")) == [
bytearray(b"1"),
bytearray(b"2"),
bytearray(b""),
bytearray(b"3"),
bytearray(b""),
]
assert bytearray(b"1 2 3").split() == [
bytearray(b"1"),
bytearray(b"2"),
bytearray(b"3"),
]
assert bytearray(b"1 2 3").split(maxsplit=1) == [bytearray(b"1"), bytearray(b"2 3")]
assert bytearray(b" 1 2 3 ").split() == [bytearray(b"1"), bytearray(b"2"), bytearray(b"3")]
assert bytearray(b"k\ruh\nfz e f").split() == [bytearray(b"k"), bytearray(b"uh"), bytearray(b"fz"), bytearray(b"e"), bytearray(b"f")]
assert bytearray(b"Two lines\n").split(bytearray(b"\n")) == [bytearray(b"Two lines"), bytearray(b"")]
assert bytearray(b" 1 2 3 ").split() == [
bytearray(b"1"),
bytearray(b"2"),
bytearray(b"3"),
]
assert bytearray(b"k\ruh\nfz e f").split() == [
bytearray(b"k"),
bytearray(b"uh"),
bytearray(b"fz"),
bytearray(b"e"),
bytearray(b"f"),
]
assert bytearray(b"Two lines\n").split(bytearray(b"\n")) == [
bytearray(b"Two lines"),
bytearray(b""),
]
assert bytearray(b"").split() == []
assert bytearray(b"").split(bytearray(b"\n")) == [bytearray(b"")]
assert bytearray(b"\n").split(bytearray(b"\n")) == [bytearray(b""), bytearray(b"")]
@@ -534,16 +565,21 @@ while n_sp < len(SPLIT_FIXTURES):
i = SPLIT_FIXTURES[n_sp]
sep = None if i[1] == None else bytearray(i[1])
try:
assert bytearray(i[0]).split(sep=sep, maxsplit=i[4]) == [bytearray(j) for j in i[2]]
assert bytearray(i[0]).split(sep=sep, maxsplit=i[4]) == [
bytearray(j) for j in i[2]
]
except AssertionError:
print(i[0], i[1], i[2])
print(
"Expected : ", [list(x) for x in bytearray(i[0]).split(sep=sep, maxsplit=i[4])]
"Expected : ",
[list(x) for x in bytearray(i[0]).split(sep=sep, maxsplit=i[4])],
)
break
try:
assert bytearray(i[0]).rsplit(sep=sep, maxsplit=i[4]) == [bytearray(j) for j in i[3]]
assert bytearray(i[0]).rsplit(sep=sep, maxsplit=i[4]) == [
bytearray(j) for j in i[3]
]
except AssertionError:
print(i[0], i[1], i[2])
print(
@@ -557,34 +593,61 @@ while n_sp < len(SPLIT_FIXTURES):
# expandtabs
a = bytearray(b"\x01\x03\r\x05\t8CYZ\t\x06CYZ\t\x17cba`\n\x12\x13\x14")
assert (
a.expandtabs() == bytearray(b"\x01\x03\r\x05 8CYZ \x06CYZ \x17cba`\n\x12\x13\x14")
assert a.expandtabs() == bytearray(
b"\x01\x03\r\x05 8CYZ \x06CYZ \x17cba`\n\x12\x13\x14"
)
assert a.expandtabs(5) == bytearray(
b"\x01\x03\r\x05 8CYZ \x06CYZ \x17cba`\n\x12\x13\x14"
)
assert bytearray(b"01\t012\t0123\t01234").expandtabs() == bytearray(
b"01 012 0123 01234"
)
assert bytearray(b"01\t012\t0123\t01234").expandtabs(4) == bytearray(
b"01 012 0123 01234"
)
assert a.expandtabs(5) == bytearray(b"\x01\x03\r\x05 8CYZ \x06CYZ \x17cba`\n\x12\x13\x14")
assert bytearray(b"01\t012\t0123\t01234").expandtabs() == bytearray(b"01 012 0123 01234")
assert bytearray(b"01\t012\t0123\t01234").expandtabs(4) == bytearray(b"01 012 0123 01234")
assert bytearray(b"123\t123").expandtabs(-5) == bytearray(b"123123")
assert bytearray(b"123\t123").expandtabs(0) == bytearray(b"123123")
# # partition
assert bytearray(b"123456789").partition(b"45") == ((b"123"), bytearray(b"45"), bytearray(b"6789"))
assert bytearray(b"14523456789").partition(b"45") == ((b"1"), bytearray(b"45"), bytearray(b"23456789"))
assert bytearray(b"123456789").partition(b"45") == (
(b"123"),
bytearray(b"45"),
bytearray(b"6789"),
)
assert bytearray(b"14523456789").partition(b"45") == (
(b"1"),
bytearray(b"45"),
bytearray(b"23456789"),
)
a = bytearray(b"14523456789").partition(b"45")
assert isinstance(a[1], bytearray)
a = bytearray(b"14523456789").partition(memoryview(b"45"))
assert isinstance(a[1], bytearray)
# partition
assert bytearray(b"123456789").rpartition(bytearray(b"45")) == ((bytearray(b"123")), bytearray(b"45"), bytearray(b"6789"))
assert bytearray(b"14523456789").rpartition(bytearray(b"45")) == ((bytearray(b"14523")), bytearray(b"45"), bytearray(b"6789"))
assert bytearray(b"123456789").rpartition(bytearray(b"45")) == (
(bytearray(b"123")),
bytearray(b"45"),
bytearray(b"6789"),
)
assert bytearray(b"14523456789").rpartition(bytearray(b"45")) == (
(bytearray(b"14523")),
bytearray(b"45"),
bytearray(b"6789"),
)
a = bytearray(b"14523456789").rpartition(b"45")
assert isinstance(a[1], bytearray)
a = bytearray(b"14523456789").rpartition(memoryview(b"45"))
assert isinstance(a[1], bytearray)
# splitlines
assert bytearray(b"ab c\n\nde fg\rkl\r\n").splitlines() == [bytearray(b"ab c"), bytearray(b""), bytearray(b"de fg"), bytearray(b"kl")]
assert bytearray(b"ab c\n\nde fg\rkl\r\n").splitlines() == [
bytearray(b"ab c"),
bytearray(b""),
bytearray(b"de fg"),
bytearray(b"kl"),
]
assert bytearray(b"ab c\n\nde fg\rkl\r\n").splitlines(keepends=True) == [
bytearray(b"ab c\n"),
bytearray(b"\n"),
@@ -602,11 +665,15 @@ assert bytearray(b"42").zfill(1) == bytearray(b"42")
assert bytearray(b"42").zfill(-1) == bytearray(b"42")
# replace
assert bytearray(b"123456789123").replace(b"23",b"XX") ==bytearray(b'1XX4567891XX')
assert bytearray(b"123456789123").replace(b"23",b"XX", 1) ==bytearray(b'1XX456789123')
assert bytearray(b"123456789123").replace(b"23",b"XX", 0) == bytearray(b"123456789123")
assert bytearray(b"123456789123").replace(b"23",b"XX", -1) ==bytearray(b'1XX4567891XX')
assert bytearray(b"123456789123").replace(b"23", bytearray(b"")) == bytearray(b"14567891")
assert bytearray(b"123456789123").replace(b"23", b"XX") == bytearray(b"1XX4567891XX")
assert bytearray(b"123456789123").replace(b"23", b"XX", 1) == bytearray(b"1XX456789123")
assert bytearray(b"123456789123").replace(b"23", b"XX", 0) == bytearray(b"123456789123")
assert bytearray(b"123456789123").replace(b"23", b"XX", -1) == bytearray(
b"1XX4567891XX"
)
assert bytearray(b"123456789123").replace(b"23", bytearray(b"")) == bytearray(
b"14567891"
)
# clear
@@ -642,25 +709,24 @@ assert a.pop() == 100
# title
assert bytearray(b"Hello world").title() == bytearray(b"Hello World")
assert (
bytearray(b"they're bill's friends from the UK").title()
== bytearray(b"They'Re Bill'S Friends From The Uk")
assert bytearray(b"they're bill's friends from the UK").title() == bytearray(
b"They'Re Bill'S Friends From The Uk"
)
# repeat by multiply
a = bytearray(b'abcd')
assert a * 0 == bytearray(b'')
assert a * -1 == bytearray(b'')
assert a * 1 == bytearray(b'abcd')
assert a * 3 == bytearray(b'abcdabcdabcd')
assert 3 * a == bytearray(b'abcdabcdabcd')
a = bytearray(b"abcd")
assert a * 0 == bytearray(b"")
assert a * -1 == bytearray(b"")
assert a * 1 == bytearray(b"abcd")
assert a * 3 == bytearray(b"abcdabcdabcd")
assert 3 * a == bytearray(b"abcdabcdabcd")
a = bytearray(b'abcd')
a = bytearray(b"abcd")
a.__imul__(3)
assert a == bytearray(b'abcdabcdabcd')
assert a == bytearray(b"abcdabcdabcd")
a.__imul__(0)
assert a == bytearray(b'')
assert a == bytearray(b"")
# copy
@@ -696,70 +762,89 @@ assert a == bytearray(b"owhello, worlwdo"), a
# remove
a = bytearray(b'abcdabcd')
a = bytearray(b"abcdabcd")
a.remove(99) # the letter c
# Only the first is removed
assert a == bytearray(b'abdabcd')
assert a == bytearray(b"abdabcd")
# reverse
a = bytearray(b'hello, world')
a = bytearray(b"hello, world")
a.reverse()
assert a == bytearray(b'dlrow ,olleh')
assert a == bytearray(b"dlrow ,olleh")
# __setitem__
a = bytearray(b'test')
a = bytearray(b"test")
a[0] = 1
assert a == bytearray(b'\x01est')
assert a == bytearray(b"\x01est")
with assert_raises(TypeError):
a[0] = b'a'
a[0] = b"a"
with assert_raises(TypeError):
a[0] = memoryview(b'a')
a[0] = memoryview(b"a")
a[:2] = [0, 9]
assert a == bytearray(b'\x00\x09st')
a[1:3] = b'test'
assert a == bytearray(b'\x00testt')
a[:6] = memoryview(b'test')
assert a == bytearray(b'test')
assert a == bytearray(b"\x00\x09st")
a[1:3] = b"test"
assert a == bytearray(b"\x00testt")
a[:6] = memoryview(b"test")
assert a == bytearray(b"test")
# mod
assert bytearray('rust%bpython%b', 'utf-8') % (b' ', b'!') == bytearray(b'rust python!')
assert bytearray('x=%i y=%f', 'utf-8') % (1, 2.5) == bytearray(b'x=1 y=2.500000')
assert bytearray("rust%bpython%b", "utf-8") % (b" ", b"!") == bytearray(b"rust python!")
assert bytearray("x=%i y=%f", "utf-8") % (1, 2.5) == bytearray(b"x=1 y=2.500000")
# eq, ne
a = bytearray(b'hello, world')
a = bytearray(b"hello, world")
b = a.copy()
assert a.__ne__(b) is False
b = bytearray(b'my bytearray')
b = bytearray(b"my bytearray")
assert a.__ne__(b) is True
# pickle
a = bytearray(b'\xffab\x80\0\0\370\0\0')
assert pickle.dumps(a, 0) == b'c__builtin__\nbytearray\np0\n(c_codecs\nencode\np1\n(V\xffab\x80\\u0000\\u0000\xf8\\u0000\\u0000\np2\nVlatin1\np3\ntp4\nRp5\ntp6\nRp7\n.'
assert pickle.dumps(a, 1) == b'c__builtin__\nbytearray\nq\x00(c_codecs\nencode\nq\x01(X\x0c\x00\x00\x00\xc3\xbfab\xc2\x80\x00\x00\xc3\xb8\x00\x00q\x02X\x06\x00\x00\x00latin1q\x03tq\x04Rq\x05tq\x06Rq\x07.'
assert pickle.dumps(a, 2) == b'\x80\x02c__builtin__\nbytearray\nq\x00c_codecs\nencode\nq\x01X\x0c\x00\x00\x00\xc3\xbfab\xc2\x80\x00\x00\xc3\xb8\x00\x00q\x02X\x06\x00\x00\x00latin1q\x03\x86q\x04Rq\x05\x85q\x06Rq\x07.'
assert pickle.dumps(a, 3) == b'\x80\x03cbuiltins\nbytearray\nq\x00C\t\xffab\x80\x00\x00\xf8\x00\x00q\x01\x85q\x02Rq\x03.'
assert pickle.dumps(a, 4) == b'\x80\x04\x95*\x00\x00\x00\x00\x00\x00\x00\x8c\x08builtins\x94\x8c\tbytearray\x94\x93\x94C\t\xffab\x80\x00\x00\xf8\x00\x00\x94\x85\x94R\x94.'
a = bytearray(b"\xffab\x80\0\0\370\0\0")
assert (
pickle.dumps(a, 0)
== b"c__builtin__\nbytearray\np0\n(c_codecs\nencode\np1\n(V\xffab\x80\\u0000\\u0000\xf8\\u0000\\u0000\np2\nVlatin1\np3\ntp4\nRp5\ntp6\nRp7\n."
)
assert (
pickle.dumps(a, 1)
== b"c__builtin__\nbytearray\nq\x00(c_codecs\nencode\nq\x01(X\x0c\x00\x00\x00\xc3\xbfab\xc2\x80\x00\x00\xc3\xb8\x00\x00q\x02X\x06\x00\x00\x00latin1q\x03tq\x04Rq\x05tq\x06Rq\x07."
)
assert (
pickle.dumps(a, 2)
== b"\x80\x02c__builtin__\nbytearray\nq\x00c_codecs\nencode\nq\x01X\x0c\x00\x00\x00\xc3\xbfab\xc2\x80\x00\x00\xc3\xb8\x00\x00q\x02X\x06\x00\x00\x00latin1q\x03\x86q\x04Rq\x05\x85q\x06Rq\x07."
)
assert (
pickle.dumps(a, 3)
== b"\x80\x03cbuiltins\nbytearray\nq\x00C\t\xffab\x80\x00\x00\xf8\x00\x00q\x01\x85q\x02Rq\x03."
)
assert (
pickle.dumps(a, 4)
== b"\x80\x04\x95*\x00\x00\x00\x00\x00\x00\x00\x8c\x08builtins\x94\x8c\tbytearray\x94\x93\x94C\t\xffab\x80\x00\x00\xf8\x00\x00\x94\x85\x94R\x94."
)
# pickle with subclass
class A(bytes):
pass
a = A()
a.x = 10
a.y = A(b'123')
a.y = A(b"123")
b = pickle.loads(pickle.dumps(a, 4))
assert type(a) == type(b)
assert a.x == b.x
assert a.y == b.y
assert a == b
class B(bytearray):
pass
a = B()
a.x = 10
a.y = B(b'123')
a.y = B(b"123")
b = pickle.loads(pickle.dumps(a, 4))
assert type(a) == type(b)
assert a.x == b.x
@@ -768,4 +853,6 @@ assert a == b
a = bytearray()
for i in range(-1, 2, 1):
assert_raises(IndexError, lambda: a[-sys.maxsize - i], _msg='bytearray index out of range')
assert_raises(
IndexError, lambda: a[-sys.maxsize - i], _msg="bytearray index out of range"
)
extra_tests/snippets/builtin_bytes.py
+32 -23
View File
@@ -596,51 +596,56 @@ assert (
# repeat by multiply
a = b'abcd'
assert a * 0 == b''
assert a * -1 == b''
assert a * 1 == b'abcd'
assert a * 3 == b'abcdabcdabcd'
assert 3 * a == b'abcdabcdabcd'
a = b"abcd"
assert a * 0 == b""
assert a * -1 == b""
assert a * 1 == b"abcd"
assert a * 3 == b"abcdabcdabcd"
assert 3 * a == b"abcdabcdabcd"
# decode
assert b'\x72\x75\x73\x74'.decode('ascii') == 'rust'
assert b'\xc2\xae\x75\x73\x74'.decode('ascii', 'replace') == '��ust'
assert b'\xc2\xae\x75\x73\x74'.decode('ascii', 'ignore') == 'ust'
assert b'\xc2\xae\x75\x73\x74'.decode('utf-8') == '®ust'
assert b'\xc2\xae\x75\x73\x74'.decode() == '®ust'
assert b'\xe4\xb8\xad\xe6\x96\x87\xe5\xad\x97'.decode('utf-8') == '中文字'
assert b"\x72\x75\x73\x74".decode("ascii") == "rust"
assert b"\xc2\xae\x75\x73\x74".decode("ascii", "replace") == "��ust"
assert b"\xc2\xae\x75\x73\x74".decode("ascii", "ignore") == "ust"
assert b"\xc2\xae\x75\x73\x74".decode("utf-8") == "®ust"
assert b"\xc2\xae\x75\x73\x74".decode() == "®ust"
assert b"\xe4\xb8\xad\xe6\x96\x87\xe5\xad\x97".decode("utf-8") == "中文字"
# mod
assert b'rust%bpython%b' % (b' ', b'!') == b'rust python!'
assert b'x=%i y=%f' % (1, 2.5) == b'x=1 y=2.500000'
assert b"rust%bpython%b" % (b" ", b"!") == b"rust python!"
assert b"x=%i y=%f" % (1, 2.5) == b"x=1 y=2.500000"
# __bytes__
def test__bytes__():
foo = b'foo\x00bar'
foo = b"foo\x00bar"
assert foo.__bytes__() == foo
assert type(foo.__bytes__()) == bytes
class bytes_subclass(bytes):
pass
bar = bytes_subclass(b'bar\x00foo')
bar = bytes_subclass(b"bar\x00foo")
assert bar.__bytes__() == bar
assert type(bar.__bytes__()) == bytes
class A:
def __bytes__(self):
return b"bytess"
assert bytes(A()) == b"bytess"
# Issue #2125
b = b'abc'
b = b"abc"
assert bytes(b) is b
# Regression to
# https://github.com/RustPython/RustPython/issues/2840
a = b'123abc!?'
a = b"123abc!?"
assert id(a) == id(a)
assert id(a) != id(a * -1)
assert id(a) != id(a * 0)
@@ -652,20 +657,24 @@ assert id(a) != id(a * 2)
class SubBytes(bytes):
pass
b = SubBytes(b'0123abc*&')
b = SubBytes(b"0123abc*&")
assert id(b) == id(b)
assert id(b) != id(b * -1)
assert id(b) != id(b * 0)
assert id(b) != id(b * 1)
assert id(b) != id(b * 2)
class B1(bytearray):
def __new__(cls, value):
assert type(value) == bytes
me = super().__new__(cls, value)
me.foo = 'bar'
me.foo = "bar"
return me
b = B1.fromhex('a0a1a2')
assert b.foo == 'bar'
skip_if_unsupported(3,11,test__bytes__)
b = B1.fromhex("a0a1a2")
assert b.foo == "bar"
skip_if_unsupported(3, 11, test__bytes__)
extra_tests/snippets/builtin_callable.py
+27 -4
View File
@@ -1,25 +1,48 @@
assert not callable(1)
def f(): pass
def f():
pass
assert callable(f)
assert callable(len)
assert callable(lambda: 1)
assert callable(int)
class C:
def __init__(self):
# must be defined on class
self.__call__ = lambda self: 1
def f(self): pass
def f(self):
pass
assert callable(C)
assert not callable(C())
assert callable(C().f)
class C:
def __call__(self): pass
def __call__(self):
pass
assert callable(C())
class C1(C): pass
class C1(C):
pass
assert callable(C1())
class C:
__call__ = 1
# CPython returns true here, but fails when actually calling it
assert callable(C())
extra_tests/snippets/builtin_chr.py
+4 -2
View File
@@ -4,5 +4,7 @@ assert "a" == chr(97)
assert "é" == chr(233)
assert "🤡" == chr(129313)
assert_raises(TypeError, chr, _msg='chr() takes exactly one argument (0 given)')
assert_raises(ValueError, chr, 0x110005, _msg='ValueError: chr() arg not in range(0x110000)')
assert_raises(TypeError, chr, _msg="chr() takes exactly one argument (0 given)")
assert_raises(
ValueError, chr, 0x110005, _msg="ValueError: chr() arg not in range(0x110000)"
)
extra_tests/snippets/builtin_dict.py
+124 -97
View File
@@ -5,49 +5,49 @@ assert len(dict()) == 0
assert len({}) == 0
assert len({"a": "b"}) == 1
assert len({"a": "b", "b": 1}) == 2
assert len({"a": "b", "b": 1, "a" + "b": 2*2}) == 3
assert len({"a": "b", "b": 1, "a" + "b": 2 * 2}) == 3
d = {}
d['a'] = d
d["a"] = d
assert repr(d) == "{'a': {...}}"
assert {'a': 123}.get('a') == 123
assert {'a': 123}.get('b') == None
assert {'a': 123}.get('b', 456) == 456
assert {"a": 123}.get("a") == 123
assert {"a": 123}.get("b") == None
assert {"a": 123}.get("b", 456) == 456
d = {'a': 123, 'b': 456}
assert list(reversed(d)) == ['b', 'a']
assert list(reversed(d.keys())) == ['b', 'a']
d = {"a": 123, "b": 456}
assert list(reversed(d)) == ["b", "a"]
assert list(reversed(d.keys())) == ["b", "a"]
assert list(reversed(d.values())) == [456, 123]
assert list(reversed(d.items())) == [('b', 456), ('a', 123)]
assert list(reversed(d.items())) == [("b", 456), ("a", 123)]
with assert_raises(StopIteration):
dict_reversed = reversed(d)
for _ in range(len(d) + 1):
next(dict_reversed)
assert 'dict' in dict().__doc__
assert "dict" in dict().__doc__
d = {'a': 123, 'b': 456}
d = {"a": 123, "b": 456}
assert 1 not in d.items()
assert 'a' not in d.items()
assert 'a', 123 not in d.items()
assert "a" not in d.items()
assert "a", 123 not in d.items()
assert () not in d.items()
assert (1) not in d.items()
assert ('a') not in d.items()
assert ('a', 123) in d.items()
assert ('b', 456) in d.items()
assert ('a', 123, 3) not in d.items()
assert ('a', 123, 'b', 456) not in d.items()
assert ("a") not in d.items()
assert ("a", 123) in d.items()
assert ("b", 456) in d.items()
assert ("a", 123, 3) not in d.items()
assert ("a", 123, "b", 456) not in d.items()
d = {1: 10, "a": "ABC", (3,4): 5}
d = {1: 10, "a": "ABC", (3, 4): 5}
assert 1 in d.keys()
assert (1) in d.keys()
assert "a" in d.keys()
assert (3,4) in d.keys()
assert (3, 4) in d.keys()
assert () not in d.keys()
assert 10 not in d.keys()
assert (1, 10) not in d.keys()
assert "abc" not in d.keys()
assert ((3,4),5) not in d.keys()
assert ((3, 4), 5) not in d.keys()
d1 = {"a": 1, "b": 2}
d2 = {"c": 3, "d": 4}
@@ -64,55 +64,55 @@ assert not d1.items().isdisjoint(d2.items())
assert not d1.keys().isdisjoint(d2.keys())
assert dict(a=2, b=3) == {'a': 2, 'b': 3}
assert dict({'a': 2, 'b': 3}, b=4) == {'a': 2, 'b': 4}
assert dict([('a', 2), ('b', 3)]) == {'a': 2, 'b': 3}
assert dict(a=2, b=3) == {"a": 2, "b": 3}
assert dict({"a": 2, "b": 3}, b=4) == {"a": 2, "b": 4}
assert dict([("a", 2), ("b", 3)]) == {"a": 2, "b": 3}
assert {} == {}
assert not {'a': 2} == {}
assert not {} == {'a': 2}
assert not {'b': 2} == {'a': 2}
assert not {'a': 4} == {'a': 2}
assert {'a': 2} == {'a': 2}
assert not {"a": 2} == {}
assert not {} == {"a": 2}
assert not {"b": 2} == {"a": 2}
assert not {"a": 4} == {"a": 2}
assert {"a": 2} == {"a": 2}
nan = float('nan')
assert {'a': nan} == {'a': nan}
nan = float("nan")
assert {"a": nan} == {"a": nan}
a = {'g': 5}
b = {'a': a, 'd': 9}
a = {"g": 5}
b = {"a": a, "d": 9}
c = dict(b)
c['d'] = 3
c['a']['g'] = 2
assert a == {'g': 2}
assert b == {'a': a, 'd': 9}
c["d"] = 3
c["a"]["g"] = 2
assert a == {"g": 2}
assert b == {"a": a, "d": 9}
a.clear()
assert len(a) == 0
a = {'a': 5, 'b': 6}
a = {"a": 5, "b": 6}
res = set()
for value in a.values():
res.add(value)
assert res == set([5,6])
res.add(value)
assert res == set([5, 6])
count = 0
for (key, value) in a.items():
assert a[key] == value
count += 1
for key, value in a.items():
assert a[key] == value
count += 1
assert count == len(a)
res = set()
for key in a.keys():
res.add(key)
assert res == set(['a','b'])
res.add(key)
assert res == set(["a", "b"])
# Deleted values are correctly skipped over:
x = {'a': 1, 'b': 2, 'c': 3, 'd': 3}
del x['c']
x = {"a": 1, "b": 2, "c": 3, "d": 3}
del x["c"]
it = iter(x.items())
assert ('a', 1) == next(it)
assert ('b', 2) == next(it)
assert ('d', 3) == next(it)
assert ("a", 1) == next(it)
assert ("b", 2) == next(it)
assert ("d", 3) == next(it)
with assert_raises(StopIteration):
next(it)
@@ -121,7 +121,7 @@ with assert_raises(KeyError) as cm:
assert cm.exception.args[0] == 10
# Iterating a dictionary is just its keys:
assert ['a', 'b', 'd'] == list(x)
assert ["a", "b", "d"] == list(x)
# Iterating view captures dictionary when iterated.
data = {1: 2, 3: 4}
@@ -140,12 +140,12 @@ assert (3, "changed") == next(items)
# But we can't add or delete items during iteration.
d = {}
a = iter(d.items())
d['a'] = 2
d["a"] = 2
b = iter(d.items())
assert ('a', 2) == next(b)
assert ("a", 2) == next(b)
with assert_raises(RuntimeError):
next(a)
del d['a']
del d["a"]
with assert_raises(RuntimeError):
next(b)
@@ -164,21 +164,23 @@ x[2] = 2
x[(5, 6)] = 5
with assert_raises(TypeError):
x[[]] # Unhashable type.
x[[]] # Unhashable type.
x["here"] = "here"
assert x.get("not here", "default") == "default"
assert x.get("here", "default") == "here"
assert x.get("not here") == None
class LengthDict(dict):
def __getitem__(self, k):
return len(k)
x = LengthDict()
assert type(x) == LengthDict
assert x['word'] == 4
assert x.get('word') is None
assert x["word"] == 4
assert x.get("word") is None
assert 5 == eval("a + word", LengthDict())
@@ -189,15 +191,19 @@ class Squares(dict):
self[k] = v
return v
x = Squares()
assert x[-5] == 25
# An object that hashes to the same value always, and compares equal if any its values match.
class Hashable(object):
def __init__(self, *args):
self.values = args
def __hash__(self):
return 1
def __eq__(self, other):
for x in self.values:
for y in other.values:
@@ -205,39 +211,40 @@ class Hashable(object):
return True
return False
x = {}
x[Hashable(1,2)] = 8
assert x[Hashable(1,2)] == 8
assert x[Hashable(3,1)] == 8
x = {}
x[Hashable(1, 2)] = 8
assert x[Hashable(1, 2)] == 8
assert x[Hashable(3, 1)] == 8
x[Hashable(8)] = 19
x[Hashable(19,8)] = 1
x[Hashable(19, 8)] = 1
assert x[Hashable(8)] == 1
assert len(x) == 2
assert list({'a': 2, 'b': 10}) == ['a', 'b']
assert list({"a": 2, "b": 10}) == ["a", "b"]
x = {}
x['a'] = 2
x['b'] = 10
assert list(x) == ['a', 'b']
x["a"] = 2
x["b"] = 10
assert list(x) == ["a", "b"]
y = x.copy()
x['c'] = 12
assert y == {'a': 2, 'b': 10}
x["c"] = 12
assert y == {"a": 2, "b": 10}
y.update({'c': 19, "d": -1, 'b': 12})
assert y == {'a': 2, 'b': 12, 'c': 19, 'd': -1}
y.update({"c": 19, "d": -1, "b": 12})
assert y == {"a": 2, "b": 12, "c": 19, "d": -1}
y.update(y)
assert y == {'a': 2, 'b': 12, 'c': 19, 'd': -1} # hasn't changed
assert y == {"a": 2, "b": 12, "c": 19, "d": -1} # hasn't changed
# KeyError has object that used as key as an .args[0]
with assert_raises(KeyError) as cm:
x['not here']
x["not here"]
assert cm.exception.args[0] == "not here"
with assert_raises(KeyError) as cm:
x.pop('not here')
x.pop("not here")
assert cm.exception.args[0] == "not here"
with assert_raises(KeyError) as cm:
@@ -247,7 +254,11 @@ with assert_raises(KeyError) as cm:
x.pop(10)
assert cm.exception.args[0] == 10
class MyClass: pass
class MyClass:
pass
obj = MyClass()
with assert_raises(KeyError) as cm:
@@ -257,49 +268,65 @@ with assert_raises(KeyError) as cm:
x.pop(obj)
assert cm.exception.args[0] == obj
x = {1: 'a', '1': None}
assert x.pop(1) == 'a'
assert x.pop('1') is None
x = {1: "a", "1": None}
assert x.pop(1) == "a"
assert x.pop("1") is None
assert x == {}
x = {1: 'a'}
assert (1, 'a') == x.popitem()
x = {1: "a"}
assert (1, "a") == x.popitem()
assert x == {}
with assert_raises(KeyError) as cm:
x.popitem()
assert cm.exception.args == ('popitem(): dictionary is empty',)
assert cm.exception.args == ("popitem(): dictionary is empty",)
x = {'a': 4}
assert 4 == x.setdefault('a', 0)
assert x['a'] == 4
assert 0 == x.setdefault('b', 0)
assert x['b'] == 0
assert None == x.setdefault('c')
assert x['c'] is None
x = {"a": 4}
assert 4 == x.setdefault("a", 0)
assert x["a"] == 4
assert 0 == x.setdefault("b", 0)
assert x["b"] == 0
assert None == x.setdefault("c")
assert x["c"] is None
assert {1: None, "b": None} == dict.fromkeys([1, "b"])
assert {1: 0, "b": 0} == dict.fromkeys([1, "b"], 0)
x = {'a': 1, 'b': 1, 'c': 1}
y = {'b': 2, 'c': 2, 'd': 2}
z = {'c': 3, 'd': 3, 'e': 3}
x = {"a": 1, "b": 1, "c": 1}
y = {"b": 2, "c": 2, "d": 2}
z = {"c": 3, "d": 3, "e": 3}
w = {1: 1, **x, 2: 2, **y, 3: 3, **z, 4: 4}
assert w == {1: 1, 'a': 1, 'b': 2, 'c': 3, 2: 2, 'd': 3, 3: 3, 'e': 3, 4: 4} # not in cpython test suite
assert w == {
1: 1,
"a": 1,
"b": 2,
"c": 3,
2: 2,
"d": 3,
3: 3,
"e": 3,
4: 4,
} # not in cpython test suite
assert str({True: True, 1.0: 1.0}) == str({True: 1.0})
class A:
def __hash__(self):
return 1
def __eq__(self, other):
return isinstance(other, A)
class B:
def __hash__(self):
return 1
def __eq__(self, other):
return isinstance(other, B)
s = {1: 0, A(): 1, B(): 2}
assert len(s) == 3
assert s[1] == 0
@@ -307,19 +334,19 @@ assert s[A()] == 1
assert s[B()] == 2
# Test dict usage in set with star expressions!
a = {'bla': 2}
b = {'c': 44, 'bla': 332, 'd': 6}
x = ['bla', 'c', 'd', 'f']
a = {"bla": 2}
b = {"c": 44, "bla": 332, "d": 6}
x = ["bla", "c", "d", "f"]
c = {*a, *b, *x}
# print(c, type(c))
assert isinstance(c, set)
assert c == {'bla', 'c', 'd', 'f'}
assert c == {"bla", "c", "d", "f"}
assert not {}.__ne__({})
assert {}.__ne__({'a':'b'})
assert {}.__ne__({"a": "b"})
assert {}.__ne__(1) == NotImplemented
it = iter({0: 1, 2: 3, 4:5, 6:7})
it = iter({0: 1, 2: 3, 4: 5, 6: 7})
assert it.__length_hint__() == 4
next(it)
assert it.__length_hint__() == 3
extra_tests/snippets/builtin_dict_union.py
+60 -47
View File
@@ -1,78 +1,91 @@
from testutils import assert_raises, skip_if_unsupported
def test_dunion_ior0():
a={1:2,2:3}
b={3:4,5:6}
a|=b
assert a == {1:2,2:3,3:4,5:6}, f"wrong value assigned {a=}"
assert b == {3:4,5:6}, f"right hand side modified, {b=}"
def test_dunion_ior0():
a = {1: 2, 2: 3}
b = {3: 4, 5: 6}
a |= b
assert a == {1: 2, 2: 3, 3: 4, 5: 6}, f"wrong value assigned {a=}"
assert b == {3: 4, 5: 6}, f"right hand side modified, {b=}"
def test_dunion_or0():
a={1:2,2:3}
b={3:4,5:6}
c=a|b
a = {1: 2, 2: 3}
b = {3: 4, 5: 6}
c = a | b
assert a == {1:2,2:3}, f"left hand side of non-assignment operator modified {a=}"
assert b == {3:4,5:6}, f"right hand side of non-assignment operator modified, {b=}"
assert c == {1:2,2:3, 3:4, 5:6}, f"unexpected result of dict union {c=}"
assert a == {1: 2, 2: 3}, f"left hand side of non-assignment operator modified {a=}"
assert b == {3: 4, 5: 6}, (
f"right hand side of non-assignment operator modified, {b=}"
)
assert c == {1: 2, 2: 3, 3: 4, 5: 6}, f"unexpected result of dict union {c=}"
def test_dunion_or1():
a={1:2,2:3}
b={3:4,5:6}
c=a.__or__(b)
a = {1: 2, 2: 3}
b = {3: 4, 5: 6}
c = a.__or__(b)
assert a == {1:2,2:3}, f"left hand side of non-assignment operator modified {a=}"
assert b == {3:4,5:6}, f"right hand side of non-assignment operator modified, {b=}"
assert c == {1:2,2:3, 3:4, 5:6}, f"unexpected result of dict union {c=}"
assert a == {1: 2, 2: 3}, f"left hand side of non-assignment operator modified {a=}"
assert b == {3: 4, 5: 6}, (
f"right hand side of non-assignment operator modified, {b=}"
)
assert c == {1: 2, 2: 3, 3: 4, 5: 6}, f"unexpected result of dict union {c=}"
def test_dunion_ror0():
a={1:2,2:3}
b={3:4,5:6}
c=b.__ror__(a)
a = {1: 2, 2: 3}
b = {3: 4, 5: 6}
c = b.__ror__(a)
assert a == {1:2,2:3}, f"left hand side of non-assignment operator modified {a=}"
assert b == {3:4,5:6}, f"right hand side of non-assignment operator modified, {b=}"
assert c == {1:2,2:3, 3:4, 5:6}, f"unexpected result of dict union {c=}"
assert a == {1: 2, 2: 3}, f"left hand side of non-assignment operator modified {a=}"
assert b == {3: 4, 5: 6}, (
f"right hand side of non-assignment operator modified, {b=}"
)
assert c == {1: 2, 2: 3, 3: 4, 5: 6}, f"unexpected result of dict union {c=}"
def test_dunion_other_types():
def perf_test_or(other_obj):
d={1:2}
d = {1: 2}
return d.__or__(other_obj) is NotImplemented
def perf_test_ror(other_obj):
d={1:2}
d = {1: 2}
return d.__ror__(other_obj) is NotImplemented
test_fct={'__or__':perf_test_or, '__ror__':perf_test_ror}
others=['FooBar', 42, [36], set([19]), ['aa'], None]
for tfn,tf in test_fct.items():
test_fct = {"__or__": perf_test_or, "__ror__": perf_test_ror}
others = ["FooBar", 42, [36], set([19]), ["aa"], None]
for tfn, tf in test_fct.items():
for other in others:
assert tf(other), f"Failed: dict {tfn}, accepted {other}"
# __ior__() has different behavior and needs to be tested separately
d = {1: 2}
assert_raises(ValueError,
lambda: d.__ior__('FooBar'),
_msg='dictionary update sequence element #0 has length 1; 2 is required')
assert_raises(TypeError,
lambda: d.__ior__(42),
_msg='\'int\' object is not iterable')
assert_raises(TypeError,
lambda: d.__ior__([36]),
_msg='cannot convert dictionary update sequence element #0 to a sequence')
assert_raises(TypeError,
lambda: d.__ior__(set([36])),
_msg='cannot convert dictionary update sequence element #0 to a sequence')
res = d.__ior__(['aa'])
assert res == {1: 2, 'a': 'a'}, f"unexpected result of dict union {res=}"
assert_raises(TypeError,
lambda: d.__ior__(None),
_msg='TypeError: \'NoneType\' object is not iterable')
assert_raises(
ValueError,
lambda: d.__ior__("FooBar"),
_msg="dictionary update sequence element #0 has length 1; 2 is required",
)
assert_raises(TypeError, lambda: d.__ior__(42), _msg="'int' object is not iterable")
assert_raises(
TypeError,
lambda: d.__ior__([36]),
_msg="cannot convert dictionary update sequence element #0 to a sequence",
)
assert_raises(
TypeError,
lambda: d.__ior__(set([36])),
_msg="cannot convert dictionary update sequence element #0 to a sequence",
)
res = d.__ior__(["aa"])
assert res == {1: 2, "a": "a"}, f"unexpected result of dict union {res=}"
assert_raises(
TypeError,
lambda: d.__ior__(None),
_msg="TypeError: 'NoneType' object is not iterable",
)
skip_if_unsupported(3, 9, test_dunion_ior0)
extra_tests/snippets/builtin_dir.py
+20 -12
View File
@@ -1,9 +1,11 @@
assert isinstance(dir(), list)
assert '__builtins__' in dir()
assert "__builtins__" in dir()
class A:
def test():
pass
def test():
pass
a = A()
@@ -13,24 +15,30 @@ assert "test" in dir(A), "test not in A"
a.x = 3
assert "x" in dir(a), "x not in a"
class B(A):
def __dir__(self):
return ('q', 'h')
def __dir__(self):
return ("q", "h")
# Gets sorted and turned into a list
assert ['h', 'q'] == dir(B())
assert ["h", "q"] == dir(B())
# This calls type.__dir__ so isn't changed (but inheritance works)!
assert 'test' in dir(A)
assert "test" in dir(A)
# eval() takes any mapping-like type, so dir() must support them
# TODO: eval() should take any mapping as locals, not just dict-derived types
class A(dict):
def __getitem__(self, x):
return dir
def keys(self):
yield 6
yield 5
def __getitem__(self, x):
return dir
def keys(self):
yield 6
yield 5
assert eval("dir()", {}, A()) == [5, 6]
import socket
extra_tests/snippets/builtin_divmod.py
+3 -3
View File
@@ -1,9 +1,9 @@
from testutils import assert_raises
assert divmod(11, 3) == (3, 2)
assert divmod(8,11) == (0, 8)
assert divmod(8, 11) == (0, 8)
assert divmod(0.873, 0.252) == (3.0, 0.11699999999999999)
assert divmod(-86340, 86400) == (-1, 60)
assert_raises(ZeroDivisionError, divmod, 5, 0, _msg='divmod by zero')
assert_raises(ZeroDivisionError, divmod, 5.0, 0.0, _msg='divmod by zero')
assert_raises(ZeroDivisionError, divmod, 5, 0, _msg="divmod by zero")
assert_raises(ZeroDivisionError, divmod, 5.0, 0.0, _msg="divmod by zero")
extra_tests/snippets/builtin_ellipsis.py
+5 -7
View File
@@ -1,5 +1,3 @@
a = ...
b = ...
c = type(a)() # Test singleton behavior
@@ -11,22 +9,22 @@ assert b is c
assert b is d
assert d is e
assert Ellipsis.__repr__() == 'Ellipsis'
assert Ellipsis.__reduce__() == 'Ellipsis'
assert Ellipsis.__repr__() == "Ellipsis"
assert Ellipsis.__reduce__() == "Ellipsis"
assert type(Ellipsis).__new__(type(Ellipsis)) == Ellipsis
assert type(Ellipsis).__reduce__(Ellipsis) == 'Ellipsis'
assert type(Ellipsis).__reduce__(Ellipsis) == "Ellipsis"
try:
type(Ellipsis).__new__(type(1))
except TypeError:
pass
else:
assert False, '`Ellipsis.__new__` should only accept `type(Ellipsis)` as argument'
assert False, "`Ellipsis.__new__` should only accept `type(Ellipsis)` as argument"
try:
type(Ellipsis).__reduce__(1)
except TypeError:
pass
else:
assert False, '`Ellipsis.__reduce__` should only accept `Ellipsis` as argument'
assert False, "`Ellipsis.__reduce__` should only accept `Ellipsis` as argument"
assert Ellipsis is ...
Ellipsis = 2
extra_tests/snippets/builtin_enumerate.py
+8 -3
View File
@@ -1,9 +1,14 @@
assert list(enumerate(['a', 'b', 'c'])) == [(0, 'a'), (1, 'b'), (2, 'c')]
assert list(enumerate(["a", "b", "c"])) == [(0, "a"), (1, "b"), (2, "c")]
assert type(enumerate([])) == enumerate
assert list(enumerate(['a', 'b', 'c'], -100)) == [(-100, 'a'), (-99, 'b'), (-98, 'c')]
assert list(enumerate(['a', 'b', 'c'], 2**200)) == [(2**200, 'a'), (2**200 + 1, 'b'), (2**200 + 2, 'c')]
assert list(enumerate(["a", "b", "c"], -100)) == [(-100, "a"), (-99, "b"), (-98, "c")]
assert list(enumerate(["a", "b", "c"], 2**200)) == [
(2**200, "a"),
(2**200 + 1, "b"),
(2**200 + 2, "c"),
]
# test infinite iterator
class Counter(object):
extra_tests/snippets/builtin_eval.py
+2 -2
View File
@@ -1,4 +1,4 @@
assert 3 == eval('1+2')
assert 3 == eval("1+2")
code = compile('5+3', 'x.py', 'eval')
code = compile("5+3", "x.py", "eval")
assert eval(code) == 8
extra_tests/snippets/builtin_exceptions.py
+77 -64
View File
@@ -3,41 +3,48 @@ import platform
import pickle
import sys
def exceptions_eq(e1, e2):
return type(e1) is type(e2) and e1.args == e2.args
def round_trip_repr(e):
return exceptions_eq(e, eval(repr(e)))
# KeyError
empty_exc = KeyError()
assert str(empty_exc) == ''
assert str(empty_exc) == ""
assert round_trip_repr(empty_exc)
assert len(empty_exc.args) == 0
assert type(empty_exc.args) == tuple
exc = KeyError('message')
exc = KeyError("message")
assert str(exc) == "'message'"
assert round_trip_repr(exc)
assert LookupError.__str__(exc) == "message"
exc = KeyError('message', 'another message')
exc = KeyError("message", "another message")
assert str(exc) == "('message', 'another message')"
assert round_trip_repr(exc)
assert exc.args[0] == 'message'
assert exc.args[1] == 'another message'
assert exc.args[0] == "message"
assert exc.args[1] == "another message"
class A:
def __repr__(self):
return 'A()'
return "A()"
def __str__(self):
return 'str'
return "str"
def __eq__(self, other):
return type(other) is A
exc = KeyError(A())
assert str(exc) == 'A()'
assert str(exc) == "A()"
assert round_trip_repr(exc)
# ImportError / ModuleNotFoundError
@@ -47,33 +54,32 @@ assert exc.path is None
assert exc.msg is None
assert exc.args == ()
exc = ImportError('hello')
exc = ImportError("hello")
assert exc.name is None
assert exc.path is None
assert exc.msg == 'hello'
assert exc.args == ('hello',)
assert exc.msg == "hello"
assert exc.args == ("hello",)
exc = ImportError('hello', name='name', path='path')
assert exc.name == 'name'
assert exc.path == 'path'
assert exc.msg == 'hello'
assert exc.args == ('hello',)
exc = ImportError("hello", name="name", path="path")
assert exc.name == "name"
assert exc.path == "path"
assert exc.msg == "hello"
assert exc.args == ("hello",)
class NewException(Exception):
def __init__(self, value):
self.value = value
def __init__(self, value):
self.value = value
try:
raise NewException("test")
raise NewException("test")
except NewException as e:
assert e.value == "test"
assert e.value == "test"
exc = SyntaxError('msg', 1, 2, 3, 4, 5)
assert exc.msg == 'msg'
exc = SyntaxError("msg", 1, 2, 3, 4, 5)
assert exc.msg == "msg"
assert exc.filename is None
assert exc.lineno is None
assert exc.offset is None
@@ -82,11 +88,12 @@ assert exc.text is None
# Regression to:
# https://github.com/RustPython/RustPython/issues/2779
class MyError(Exception):
pass
e = MyError('message')
e = MyError("message")
try:
raise e from e
@@ -97,23 +104,23 @@ except MyError as exc:
assert exc.__cause__ is e
assert exc.__context__ is None
else:
assert False, 'exception not raised'
assert False, "exception not raised"
try:
raise ValueError('test') from e
raise ValueError("test") from e
except ValueError as exc:
sys.excepthook(type(exc), exc, exc.__traceback__) # ok, will print two excs
assert isinstance(exc, ValueError)
assert exc.__cause__ is e
assert exc.__context__ is None
else:
assert False, 'exception not raised'
assert False, "exception not raised"
# New case:
# potential recursion on `__context__` field
e = MyError('message')
e = MyError("message")
try:
try:
@@ -121,15 +128,15 @@ try:
except MyError as exc:
raise e
else:
assert False, 'exception not raised'
assert False, "exception not raised"
except MyError as exc:
sys.excepthook(type(exc), exc, exc.__traceback__)
assert exc.__cause__ is None
assert exc.__context__ is None
else:
assert False, 'exception not raised'
assert False, "exception not raised"
e = MyError('message')
e = MyError("message")
try:
try:
@@ -137,15 +144,15 @@ try:
except MyError as exc:
raise exc
else:
assert False, 'exception not raised'
assert False, "exception not raised"
except MyError as exc:
sys.excepthook(type(exc), exc, exc.__traceback__)
assert exc.__cause__ is None
assert exc.__context__ is None
else:
assert False, 'exception not raised'
assert False, "exception not raised"
e = MyError('message')
e = MyError("message")
try:
try:
@@ -153,15 +160,15 @@ try:
except MyError as exc:
raise e from e
else:
assert False, 'exception not raised'
assert False, "exception not raised"
except MyError as exc:
sys.excepthook(type(exc), exc, exc.__traceback__)
assert exc.__cause__ is e
assert exc.__context__ is None
else:
assert False, 'exception not raised'
assert False, "exception not raised"
e = MyError('message')
e = MyError("message")
try:
try:
@@ -169,23 +176,25 @@ try:
except MyError as exc:
raise exc from e
else:
assert False, 'exception not raised'
assert False, "exception not raised"
except MyError as exc:
sys.excepthook(type(exc), exc, exc.__traceback__)
assert exc.__cause__ is e
assert exc.__context__ is None
else:
assert False, 'exception not raised'
assert False, "exception not raised"
# New case:
# two exception in a recursion loop
class SubError(MyError):
pass
e = MyError('message')
d = SubError('sub')
e = MyError("message")
d = SubError("sub")
try:
@@ -197,9 +206,9 @@ except MyError as exc:
assert exc.__cause__ is d
assert exc.__context__ is None
else:
assert False, 'exception not raised'
assert False, "exception not raised"
e = MyError('message')
e = MyError("message")
try:
raise d from e
@@ -210,20 +219,20 @@ except SubError as exc:
assert exc.__cause__ is e
assert exc.__context__ is None
else:
assert False, 'exception not raised'
assert False, "exception not raised"
# New case:
# explicit `__context__` manipulation.
e = MyError('message')
e = MyError("message")
e.__context__ = e
try:
raise e
except MyError as exc:
# It was a segmentation fault before, will print info to stdout:
if platform.python_implementation() == 'RustPython':
if platform.python_implementation() == "RustPython":
# For some reason `CPython` hangs on this code:
sys.excepthook(type(exc), exc, exc.__traceback__)
assert isinstance(exc, MyError)
@@ -235,30 +244,36 @@ except MyError as exc:
# https://github.com/RustPython/RustPython/issues/2771
# `BaseException` and `Exception`:
assert BaseException.__new__.__qualname__ == 'BaseException.__new__'
assert BaseException.__init__.__qualname__ == 'BaseException.__init__'
assert BaseException.__new__.__qualname__ == "BaseException.__new__"
assert BaseException.__init__.__qualname__ == "BaseException.__init__"
assert BaseException().__dict__ == {}
assert Exception.__new__.__qualname__ == 'Exception.__new__', Exception.__new__.__qualname__
assert Exception.__init__.__qualname__ == 'Exception.__init__', Exception.__init__.__qualname__
assert Exception.__new__.__qualname__ == "Exception.__new__", (
Exception.__new__.__qualname__
)
assert Exception.__init__.__qualname__ == "Exception.__init__", (
Exception.__init__.__qualname__
)
assert Exception().__dict__ == {}
# Extends `BaseException`, simple:
assert KeyboardInterrupt.__new__.__qualname__ == 'KeyboardInterrupt.__new__', KeyboardInterrupt.__new__.__qualname__
assert KeyboardInterrupt.__init__.__qualname__ == 'KeyboardInterrupt.__init__'
assert KeyboardInterrupt.__new__.__qualname__ == "KeyboardInterrupt.__new__", (
KeyboardInterrupt.__new__.__qualname__
)
assert KeyboardInterrupt.__init__.__qualname__ == "KeyboardInterrupt.__init__"
assert KeyboardInterrupt().__dict__ == {}
# Extends `Exception`, simple:
assert TypeError.__new__.__qualname__ == 'TypeError.__new__'
assert TypeError.__init__.__qualname__ == 'TypeError.__init__'
assert TypeError.__new__.__qualname__ == "TypeError.__new__"
assert TypeError.__init__.__qualname__ == "TypeError.__init__"
assert TypeError().__dict__ == {}
# Extends `Exception`, complex:
assert OSError.__new__.__qualname__ == 'OSError.__new__'
assert OSError.__init__.__qualname__ == 'OSError.__init__'
assert OSError.__new__.__qualname__ == "OSError.__new__"
assert OSError.__init__.__qualname__ == "OSError.__init__"
assert OSError().__dict__ == {}
assert OSError.errno
assert OSError.strerror
@@ -299,7 +314,7 @@ assert x.filename == None
assert x.filename2 == None
assert str(x) == "0"
w = OSError('foo')
w = OSError("foo")
assert w.errno == None
assert not sys.platform.startswith("win") or w.winerror == None
assert w.strerror == None
@@ -315,7 +330,7 @@ assert x.filename == None
assert x.filename2 == None
assert str(x) == "foo"
w = OSError('a', 'b', 'c', 'd', 'e', 'f')
w = OSError("a", "b", "c", "d", "e", "f")
assert w.errno == None
assert not sys.platform.startswith("win") or w.winerror == None
assert w.strerror == None
@@ -332,12 +347,10 @@ assert x.filename2 == None
assert str(x) == "('a', 'b', 'c', 'd', 'e', 'f')"
# Custom `__new__` and `__init__`:
assert ImportError.__init__.__qualname__ == 'ImportError.__init__'
assert ImportError(name='a').name == 'a'
assert (
ModuleNotFoundError.__init__.__qualname__ == 'ModuleNotFoundError.__init__'
)
assert ModuleNotFoundError(name='a').name == 'a'
assert ImportError.__init__.__qualname__ == "ImportError.__init__"
assert ImportError(name="a").name == "a"
assert ModuleNotFoundError.__init__.__qualname__ == "ModuleNotFoundError.__init__"
assert ModuleNotFoundError(name="a").name == "a"
# Check that all exceptions have string `__doc__`:
extra_tests/snippets/builtin_exec.py
+19 -12
View File
@@ -3,11 +3,11 @@ assert 16 == square(4) # noqa: F821
d = {}
exec("def square(x):\n return x * x\n", {}, d)
assert 16 == d['square'](4)
assert 16 == d["square"](4)
exec("assert 2 == x", {}, {'x': 2})
exec("assert 2 == x", {'x': 2}, {})
exec("assert 4 == x", {'x': 2}, {'x': 4})
exec("assert 2 == x", {}, {"x": 2})
exec("assert 2 == x", {"x": 2}, {})
exec("assert 4 == x", {"x": 2}, {"x": 4})
exec("assert max(1, 2) == 2", {}, {})
@@ -16,9 +16,11 @@ exec("assert max(1, 5, square(5)) == 25", None)
# Local environment shouldn't replace global environment:
exec("assert max(1, 5, square(5)) == 25", None, {})
# Closures aren't available if local scope is replaced:
def g():
seven = "seven"
def f():
try:
exec("seven", None, {})
@@ -26,7 +28,10 @@ def g():
pass
else:
raise NameError("seven shouldn't be in scope")
f()
g()
try:
@@ -37,16 +42,16 @@ else:
raise TypeError("exec should fail unless globals is a dict or None")
g = globals()
g['x'] = 2
exec('x += 2')
g["x"] = 2
exec("x += 2")
assert x == 4 # noqa: F821
assert g['x'] == x # noqa: F821
assert g["x"] == x # noqa: F821
exec("del x")
assert 'x' not in g
assert "x" not in g
assert 'g' in globals()
assert 'g' in locals()
assert "g" in globals()
assert "g" in locals()
exec("assert 'g' in globals()")
exec("assert 'g' in locals()")
exec("assert 'g' not in globals()", {})
@@ -54,13 +59,15 @@ exec("assert 'g' not in locals()", {})
del g
def f():
g = 1
assert 'g' not in globals()
assert 'g' in locals()
assert "g" not in globals()
assert "g" in locals()
exec("assert 'g' not in globals()")
exec("assert 'g' in locals()")
exec("assert 'g' not in globals()", {})
exec("assert 'g' not in locals()", {})
f()
extra_tests/snippets/builtin_exit.py
+1 -1
View File
@@ -36,4 +36,4 @@ with assert_raises(SystemExit):
sys.exit(1)
with assert_raises(SystemExit):
sys.exit("AB")
sys.exit("AB")
extra_tests/snippets/builtin_format.py
+65 -33
View File
@@ -2,37 +2,52 @@ from testutils import assert_raises
assert format(5, "b") == "101"
assert_raises(TypeError, format, 2, 3, _msg='format called with number')
assert_raises(TypeError, format, 2, 3, _msg="format called with number")
assert format({}) == "{}"
assert_raises(TypeError, format, {}, 'b', _msg='format_spec not empty for dict')
assert_raises(TypeError, format, {}, "b", _msg="format_spec not empty for dict")
class BadFormat:
def __format__(self, spec):
return 42
assert_raises(TypeError, format, BadFormat())
def test_zero_padding():
i = 1
assert f'{i:04d}' == '0001'
assert f"{i:04d}" == "0001"
test_zero_padding()
assert '{:,}'.format(100) == '100'
assert '{:,}'.format(1024) == '1,024'
assert '{:_}'.format(65536) == '65_536'
assert '{:_}'.format(4294967296) == '4_294_967_296'
assert f'{100:_}' == '100'
assert f'{1024:_}' == '1_024'
assert f'{65536:,}' == '65,536'
assert f'{4294967296:,}' == '4,294,967,296'
assert 'F' == "{0:{base}}".format(15, base="X")
assert f'{255:#X}' == "0XFF"
assert "{:,}".format(100) == "100"
assert "{:,}".format(1024) == "1,024"
assert "{:_}".format(65536) == "65_536"
assert "{:_}".format(4294967296) == "4_294_967_296"
assert f"{100:_}" == "100"
assert f"{1024:_}" == "1_024"
assert f"{65536:,}" == "65,536"
assert f"{4294967296:,}" == "4,294,967,296"
assert "F" == "{0:{base}}".format(15, base="X")
assert f"{255:#X}" == "0XFF"
assert f"{65:c}" == "A"
assert f"{0x1f5a5:c}" == "🖥"
assert_raises(ValueError, "{:+c}".format, 1, _msg="Sign not allowed with integer format specifier 'c'")
assert_raises(ValueError, "{:#c}".format, 1, _msg="Alternate form (#) not allowed with integer format specifier 'c'")
assert f"{0x1F5A5:c}" == "🖥"
assert_raises(
ValueError,
"{:+c}".format,
1,
_msg="Sign not allowed with integer format specifier 'c'",
)
assert_raises(
ValueError,
"{:#c}".format,
1,
_msg="Alternate form (#) not allowed with integer format specifier 'c'",
)
assert f"{256:#010x}" == "0x00000100"
assert f"{256:0=#10x}" == "0x00000100"
assert f"{256:0>#10x}" == "000000x100"
@@ -66,14 +81,31 @@ assert f"{123.456:011,}" == "000,123.456"
assert f"{123.456:+011,}" == "+00,123.456"
assert f"{1234:.3g}" == "1.23e+03"
assert f"{1234567:.6G}" == "1.23457E+06"
assert f'{"🐍":4}' == "🐍 "
assert_raises(ValueError, "{:,o}".format, 1, _msg="ValueError: Cannot specify ',' with 'o'.")
assert_raises(ValueError, "{:_n}".format, 1, _msg="ValueError: Cannot specify '_' with 'n'.")
assert_raises(ValueError, "{:,o}".format, 1.0, _msg="ValueError: Cannot specify ',' with 'o'.")
assert_raises(ValueError, "{:_n}".format, 1.0, _msg="ValueError: Cannot specify '_' with 'n'.")
assert_raises(ValueError, "{:,}".format, "abc", _msg="ValueError: Cannot specify ',' with 's'.")
assert_raises(ValueError, "{:,x}".format, "abc", _msg="ValueError: Cannot specify ',' with 'x'.")
assert_raises(OverflowError, "{:c}".format, 0x110000, _msg="OverflowError: %c arg not in range(0x110000)")
assert f"{'🐍':4}" == "🐍 "
assert_raises(
ValueError, "{:,o}".format, 1, _msg="ValueError: Cannot specify ',' with 'o'."
)
assert_raises(
ValueError, "{:_n}".format, 1, _msg="ValueError: Cannot specify '_' with 'n'."
)
assert_raises(
ValueError, "{:,o}".format, 1.0, _msg="ValueError: Cannot specify ',' with 'o'."
)
assert_raises(
ValueError, "{:_n}".format, 1.0, _msg="ValueError: Cannot specify '_' with 'n'."
)
assert_raises(
ValueError, "{:,}".format, "abc", _msg="ValueError: Cannot specify ',' with 's'."
)
assert_raises(
ValueError, "{:,x}".format, "abc", _msg="ValueError: Cannot specify ',' with 'x'."
)
assert_raises(
OverflowError,
"{:c}".format,
0x110000,
_msg="OverflowError: %c arg not in range(0x110000)",
)
assert f"{3:f}" == "3.000000"
assert f"{3.1415:.0f}" == "3"
assert f"{3.1415:.1f}" == "3.1"
@@ -115,14 +147,14 @@ assert f"{3.1415:#.3e}" == "3.142e+00"
assert f"{3.1415:#.4e}" == "3.1415e+00"
assert f"{3.1415:#.5e}" == "3.14150e+00"
assert f"{3.1415:#.5E}" == "3.14150E+00"
assert f"{3.1415:.0%}" == '314%'
assert f"{3.1415:.1%}" == '314.2%'
assert f"{3.1415:.2%}" == '314.15%'
assert f"{3.1415:.3%}" == '314.150%'
assert f"{3.1415:#.0%}" == '314.%'
assert f"{3.1415:#.1%}" == '314.2%'
assert f"{3.1415:#.2%}" == '314.15%'
assert f"{3.1415:#.3%}" == '314.150%'
assert f"{3.1415:.0%}" == "314%"
assert f"{3.1415:.1%}" == "314.2%"
assert f"{3.1415:.2%}" == "314.15%"
assert f"{3.1415:.3%}" == "314.150%"
assert f"{3.1415:#.0%}" == "314.%"
assert f"{3.1415:#.1%}" == "314.2%"
assert f"{3.1415:#.2%}" == "314.15%"
assert f"{3.1415:#.3%}" == "314.150%"
assert f"{3.1415:.0}" == "3e+00"
assert f"{3.1415:.1}" == "3e+00"
assert f"{3.1415:.2}" == "3.1"
@@ -137,5 +169,5 @@ assert f"{3.1415:#.4}" == "3.142"
# test issue 4558
x = 123456789012345678901234567890
for i in range(0, 30):
format(x, ',')
format(x, ",")
x = x // 10
extra_tests/snippets/builtin_hash.py
-1
View File
@@ -1,4 +1,3 @@
from testutils import assert_raises
extra_tests/snippets/builtin_hex.py
+3 -3
View File
@@ -1,6 +1,6 @@
from testutils import assert_raises
assert hex(16) == '0x10'
assert hex(-16) == '-0x10'
assert hex(16) == "0x10"
assert hex(-16) == "-0x10"
assert_raises(TypeError, hex, {}, _msg='ord() called with dict')
assert_raises(TypeError, hex, {}, _msg="ord() called with dict")
extra_tests/snippets/builtin_isinstance.py
+13 -2
View File
@@ -1,4 +1,3 @@
class Regular:
pass
@@ -41,14 +40,17 @@ assert isinstance(AlwaysInstanceOf(), AlwaysInstanceOf)
assert isinstance(Regular(), AlwaysInstanceOf)
assert isinstance(1, AlwaysInstanceOf)
class GenericInstance:
def __instancecheck__(self, _):
return True
assert isinstance(Regular(), GenericInstance())
assert isinstance([], GenericInstance())
assert isinstance(1, GenericInstance())
class MCReturnInt(type):
def __instancecheck__(self, instance):
return 3
@@ -60,4 +62,13 @@ class ReturnInt(metaclass=MCReturnInt):
assert isinstance("a", ReturnInt) is True
assert isinstance(1, ((int, float,), str))
assert isinstance(
1,
(
(
int,
float,
),
str,
),
)
extra_tests/snippets/builtin_issubclass.py
+3 -1
View File
@@ -1,4 +1,3 @@
class A:
pass
@@ -49,14 +48,17 @@ assert issubclass(AlwaysSubClass, AlwaysSubClass)
assert issubclass(InheritedAlwaysSubClass, AlwaysSubClass)
assert issubclass(AlwaysSubClass, InheritedAlwaysSubClass)
class GenericInstance:
def __subclasscheck__(self, _):
return True
assert issubclass(A, GenericInstance())
assert issubclass(list, GenericInstance())
assert issubclass([], GenericInstance())
class MCAVirtualSubClass(type):
def __subclasscheck__(self, subclass):
return subclass is A
extra_tests/snippets/builtin_len.py
+2 -2
View File
@@ -1,2 +1,2 @@
assert 3 == len([1,2,3])
assert 2 == len((1,2))
assert 3 == len([1, 2, 3])
assert 2 == len((1, 2))
extra_tests/snippets/builtin_list.py
+329 -172
View File
@@ -12,38 +12,85 @@ y.extend(x)
assert y == [2, 1, 2, 3, 1, 2, 3]
a = []
a.extend((1,2,3,4))
a.extend((1, 2, 3, 4))
assert a == [1, 2, 3, 4]
a.extend('abcdefg')
assert a == [1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e', 'f', 'g']
a.extend("abcdefg")
assert a == [1, 2, 3, 4, "a", "b", "c", "d", "e", "f", "g"]
a.extend(range(10))
assert a == [1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
assert a == [
1,
2,
3,
4,
"a",
"b",
"c",
"d",
"e",
"f",
"g",
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
]
a = []
a.extend({1,2,3,4})
a.extend({1, 2, 3, 4})
assert a == [1, 2, 3, 4]
a.extend({'a': 1, 'b': 2, 'z': 51})
assert a == [1, 2, 3, 4, 'a', 'b', 'z']
a.extend({"a": 1, "b": 2, "z": 51})
assert a == [1, 2, 3, 4, "a", "b", "z"]
class Iter:
def __iter__(self):
yield 12
yield 28
a.extend(Iter())
assert a == [1, 2, 3, 4, 'a', 'b', 'z', 12, 28]
a.extend(bytes(b'hello world'))
assert a == [1, 2, 3, 4, 'a', 'b', 'z', 12, 28, 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
a.extend(Iter())
assert a == [1, 2, 3, 4, "a", "b", "z", 12, 28]
a.extend(bytes(b"hello world"))
assert a == [
1,
2,
3,
4,
"a",
"b",
"z",
12,
28,
104,
101,
108,
108,
111,
32,
119,
111,
114,
108,
100,
]
class Next:
def __next__(self):
yield 12
yield 28
assert_raises(TypeError, lambda: [].extend(3))
assert_raises(TypeError, lambda: [].extend(slice(0, 10, 1)))
@@ -56,12 +103,12 @@ assert y is x
assert x == [1, 2, 3] * 2
# index()
assert ['a', 'b', 'c'].index('b') == 1
assert ["a", "b", "c"].index("b") == 1
assert [5, 6, 7].index(7) == 2
assert_raises(ValueError, lambda: ['a', 'b', 'c'].index('z'))
assert_raises(ValueError, lambda: ["a", "b", "c"].index("z"))
x = [[1,0,-3], 'a', 1]
y = [[3,2,1], 'z', 2]
x = [[1, 0, -3], "a", 1]
y = [[3, 2, 1], "z", 2]
assert x < y, "list __lt__ failed"
x = [5, 13, 31]
@@ -73,9 +120,12 @@ x = [0, 1, 2]
assert x.pop() == 2
assert x == [0, 1]
def test_pop(lst, idx, value, new_lst):
assert lst.pop(idx) == value
assert lst == new_lst
test_pop([0, 1, 2], -1, 2, [0, 1])
test_pop([0, 1, 2], 0, 0, [1, 2])
test_pop([0, 1, 2], 1, 1, [0, 2])
@@ -91,23 +141,23 @@ recursive.append(recursive)
assert repr(recursive) == "[[...]]"
# insert()
x = ['a', 'b', 'c']
x.insert(0, 'z') # insert is in-place, no return value
assert x == ['z', 'a', 'b', 'c']
x = ["a", "b", "c"]
x.insert(0, "z") # insert is in-place, no return value
assert x == ["z", "a", "b", "c"]
x = ['a', 'b', 'c']
x.insert(100, 'z')
assert x == ['a', 'b', 'c', 'z']
x = ["a", "b", "c"]
x.insert(100, "z")
assert x == ["a", "b", "c", "z"]
x = ['a', 'b', 'c']
x.insert(-1, 'z')
assert x == ['a', 'b', 'z', 'c']
x = ["a", "b", "c"]
x.insert(-1, "z")
assert x == ["a", "b", "z", "c"]
x = ['a', 'b', 'c']
x.insert(-100, 'z')
assert x == ['z', 'a', 'b', 'c']
x = ["a", "b", "c"]
x.insert(-100, "z")
assert x == ["z", "a", "b", "c"]
assert_raises(OverflowError, lambda: x.insert(100000000000000000000, 'z'))
assert_raises(OverflowError, lambda: x.insert(100000000000000000000, "z"))
x = [[], 2, {}]
y = x.copy()
@@ -123,7 +173,7 @@ a.remove(1)
assert len(a) == 2
assert not 1 in a
assert_raises(ValueError, lambda: a.remove(10), _msg='Remove not exist element')
assert_raises(ValueError, lambda: a.remove(10), _msg="Remove not exist element")
foo = bar = [1]
foo += [2]
@@ -138,10 +188,12 @@ assert x.count(x) == 1
x.remove(x)
assert x not in x
class Foo(object):
def __eq__(self, x):
return False
foo = Foo()
foo1 = Foo()
x = [1, foo, 2, foo, []]
@@ -173,17 +225,17 @@ assert a == b
assert [foo] == [foo]
for size in [1, 2, 3, 4, 5, 8, 10, 100, 1000]:
lst = list(range(size))
orig = lst[:]
lst.sort()
assert lst == orig
assert sorted(lst) == orig
assert_raises(ZeroDivisionError, sorted, lst, key=lambda x: 1/x)
lst.reverse()
assert sorted(lst) == orig
assert sorted(lst, reverse=True) == lst
assert sorted(lst, key=lambda x: -x) == lst
assert sorted(lst, key=lambda x: -x, reverse=True) == orig
lst = list(range(size))
orig = lst[:]
lst.sort()
assert lst == orig
assert sorted(lst) == orig
assert_raises(ZeroDivisionError, sorted, lst, key=lambda x: 1 / x)
lst.reverse()
assert sorted(lst) == orig
assert sorted(lst, reverse=True) == lst
assert sorted(lst, key=lambda x: -x) == lst
assert sorted(lst, key=lambda x: -x, reverse=True) == orig
assert sorted([(1, 2, 3), (0, 3, 6)]) == [(0, 3, 6), (1, 2, 3)]
assert sorted([(1, 2, 3), (0, 3, 6)], key=lambda x: x[0]) == [(0, 3, 6), (1, 2, 3)]
@@ -191,34 +243,52 @@ assert sorted([(1, 2, 3), (0, 3, 6)], key=lambda x: x[1]) == [(1, 2, 3), (0, 3,
assert sorted([(1, 2), (), (5,)], key=len) == [(), (5,), (1, 2)]
lst = [3, 1, 5, 2, 4]
class C:
def __init__(self, x): self.x = x
def __lt__(self, other): return self.x < other.x
def __init__(self, x):
self.x = x
def __lt__(self, other):
return self.x < other.x
lst.sort(key=C)
assert lst == [1, 2, 3, 4, 5]
lst = [3, 1, 5, 2, 4]
class C:
def __init__(self, x): self.x = x
def __gt__(self, other): return self.x > other.x
def __init__(self, x):
self.x = x
def __gt__(self, other):
return self.x > other.x
lst.sort(key=C)
assert lst == [1, 2, 3, 4, 5]
lst = [5, 1, 2, 3, 4]
def f(x):
lst.append(1)
return x
assert_raises(ValueError, lambda: lst.sort(key=f)) # "list modified during sort"
assert_raises(ValueError, lambda: lst.sort(key=f)) # "list modified during sort"
assert lst == [1, 2, 3, 4, 5]
# __delitem__
x = ['a', 'b', 'c']
x = ["a", "b", "c"]
del x[0]
assert x == ['b', 'c']
assert x == ["b", "c"]
x = ['a', 'b', 'c']
x = ["a", "b", "c"]
del x[-1]
assert x == ['a', 'b']
assert x == ["a", "b"]
x = y = [1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15]
del x[2:14:3]
@@ -232,24 +302,30 @@ assert x == [1, 2, 3, 4, 5, 6, 7, 8, 10]
x = list(range(12))
del x[10:2:-2]
assert x == [0,1,2,3,5,7,9,11]
assert x == [0, 1, 2, 3, 5, 7, 9, 11]
def bad_del_1():
del ['a', 'b']['a']
del ["a", "b"]["a"]
assert_raises(TypeError, bad_del_1)
def bad_del_2():
del ['a', 'b'][2]
del ["a", "b"][2]
assert_raises(IndexError, bad_del_2)
# __setitem__
# simple index
x = [1, 2, 3, 4, 5]
x[0] = 'a'
assert x == ['a', 2, 3, 4, 5]
x[-1] = 'b'
assert x == ['a', 2, 3, 4, 'b']
x[0] = "a"
assert x == ["a", 2, 3, 4, 5]
x[-1] = "b"
assert x == ["a", 2, 3, 4, "b"]
# make sure refrences are assigned correctly
y = []
x[1] = y
@@ -257,14 +333,17 @@ y.append(100)
assert x[1] == y
assert x[1] == [100]
#index bounds
# index bounds
def set_index_out_of_bounds_high():
x = [0, 1, 2, 3, 4]
x[5] = 'a'
x = [0, 1, 2, 3, 4]
x[5] = "a"
def set_index_out_of_bounds_low():
x = [0, 1, 2, 3, 4]
x[-6] = 'a'
x = [0, 1, 2, 3, 4]
x[-6] = "a"
assert_raises(IndexError, set_index_out_of_bounds_high)
assert_raises(IndexError, set_index_out_of_bounds_low)
@@ -275,20 +354,20 @@ x = a[:]
y = a[:]
assert x == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# replace whole list
x[:] = ['a', 'b', 'c']
y[::1] = ['a', 'b', 'c']
assert x == ['a', 'b', 'c']
x[:] = ["a", "b", "c"]
y[::1] = ["a", "b", "c"]
assert x == ["a", "b", "c"]
assert x == y
# splice list start
x = a[:]
y = a[:]
z = a[:]
zz = a[:]
x[:1] = ['a', 'b', 'c']
y[0:1] = ['a', 'b', 'c']
z[:1:1] = ['a', 'b', 'c']
zz[0:1:1] = ['a', 'b', 'c']
assert x == ['a', 'b', 'c', 1, 2, 3, 4, 5, 6, 7, 8, 9]
x[:1] = ["a", "b", "c"]
y[0:1] = ["a", "b", "c"]
z[:1:1] = ["a", "b", "c"]
zz[0:1:1] = ["a", "b", "c"]
assert x == ["a", "b", "c", 1, 2, 3, 4, 5, 6, 7, 8, 9]
assert x == y
assert x == z
assert x == zz
@@ -297,11 +376,11 @@ x = a[:]
y = a[:]
z = a[:]
zz = a[:]
x[5:] = ['a', 'b', 'c']
y[5::1] = ['a', 'b', 'c']
z[5:10] = ['a', 'b', 'c']
zz[5:10:1] = ['a', 'b', 'c']
assert x == [0, 1, 2, 3, 4, 'a', 'b', 'c']
x[5:] = ["a", "b", "c"]
y[5::1] = ["a", "b", "c"]
z[5:10] = ["a", "b", "c"]
zz[5:10:1] = ["a", "b", "c"]
assert x == [0, 1, 2, 3, 4, "a", "b", "c"]
assert x == y
assert x == z
assert x == zz
@@ -310,11 +389,11 @@ x = a[:]
y = a[:]
z = a[:]
zz = a[:]
x[1:1] = ['a', 'b', 'c']
y[1:0] = ['a', 'b', 'c']
z[1:1:1] = ['a', 'b', 'c']
zz[1:0:1] = ['a', 'b', 'c']
assert x == [0, 'a', 'b', 'c', 1, 2, 3, 4, 5, 6, 7, 8, 9]
x[1:1] = ["a", "b", "c"]
y[1:0] = ["a", "b", "c"]
z[1:1:1] = ["a", "b", "c"]
zz[1:0:1] = ["a", "b", "c"]
assert x == [0, "a", "b", "c", 1, 2, 3, 4, 5, 6, 7, 8, 9]
assert x == y
assert x == z
assert x == zz
@@ -323,24 +402,24 @@ x = a[:]
y = a[:]
z = a[:]
zz = a[:]
x[-1:-1] = ['a', 'b', 'c']
y[-1:9] = ['a', 'b', 'c']
z[-1:-1:1] = ['a', 'b', 'c']
zz[-1:9:1] = ['a', 'b', 'c']
assert x == [0, 1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c', 9]
x[-1:-1] = ["a", "b", "c"]
y[-1:9] = ["a", "b", "c"]
z[-1:-1:1] = ["a", "b", "c"]
zz[-1:9:1] = ["a", "b", "c"]
assert x == [0, 1, 2, 3, 4, 5, 6, 7, 8, "a", "b", "c", 9]
assert x == y
assert x == z
assert x == zz
# splice mid
x = a[:]
y = a[:]
x[3:5] = ['a', 'b', 'c', 'd', 'e']
y[3:5:1] = ['a', 'b', 'c', 'd', 'e']
assert x == [0, 1, 2, 'a', 'b', 'c', 'd', 'e', 5, 6, 7, 8, 9]
x[3:5] = ["a", "b", "c", "d", "e"]
y[3:5:1] = ["a", "b", "c", "d", "e"]
assert x == [0, 1, 2, "a", "b", "c", "d", "e", 5, 6, 7, 8, 9]
assert x == y
x = a[:]
x[3:5] = ['a']
assert x == [0, 1, 2, 'a', 5, 6, 7, 8, 9]
x[3:5] = ["a"]
assert x == [0, 1, 2, "a", 5, 6, 7, 8, 9]
# assign empty to non stepped empty slice does nothing
x = a[:]
y = a[:]
@@ -359,84 +438,93 @@ assert x == y
yy = []
x = a[:]
y = a[:]
x[3:5] = ['a', 'b', 'c', 'd', yy]
y[3:5:1] = ['a', 'b', 'c', 'd', yy]
assert x == [0, 1, 2, 'a', 'b', 'c', 'd', [], 5, 6, 7, 8, 9]
x[3:5] = ["a", "b", "c", "d", yy]
y[3:5:1] = ["a", "b", "c", "d", yy]
assert x == [0, 1, 2, "a", "b", "c", "d", [], 5, 6, 7, 8, 9]
assert x == y
yy.append(100)
assert x == [0, 1, 2, 'a', 'b', 'c', 'd', [100], 5, 6, 7, 8, 9]
assert x == [0, 1, 2, "a", "b", "c", "d", [100], 5, 6, 7, 8, 9]
assert x == y
assert x[7] == yy
assert x[7] == [100]
assert y[7] == yy
assert y[7] == [100]
# no zero step
def no_zero_step_set():
x = [1, 2, 3, 4, 5]
x[0:4:0] = [11, 12, 13, 14, 15]
x = [1, 2, 3, 4, 5]
x[0:4:0] = [11, 12, 13, 14, 15]
assert_raises(ValueError, no_zero_step_set)
# stepped slice index
# forward slice
x = a[:]
x[2:8:2] = ['a', 'b', 'c']
assert x == [0, 1, 'a', 3, 'b', 5, 'c', 7, 8, 9]
x[2:8:2] = ["a", "b", "c"]
assert x == [0, 1, "a", 3, "b", 5, "c", 7, 8, 9]
x = a[:]
y = a[:]
z = a[:]
zz = a[:]
c = ['a', 'b', 'c', 'd', 'e']
c = ["a", "b", "c", "d", "e"]
x[::2] = c
y[-10::2] = c
z[0:10:2] = c
zz[-13:13:2] = c # slice indexes will be truncated to bounds
assert x == ['a', 1, 'b', 3, 'c', 5, 'd', 7, 'e', 9]
zz[-13:13:2] = c # slice indexes will be truncated to bounds
assert x == ["a", 1, "b", 3, "c", 5, "d", 7, "e", 9]
assert x == y
assert x == z
assert x == zz
# backward slice
x = a[:]
x[8:2:-2] = ['a', 'b', 'c']
assert x == [0, 1, 2, 3, 'c', 5, 'b', 7, 'a', 9]
x[8:2:-2] = ["a", "b", "c"]
assert x == [0, 1, 2, 3, "c", 5, "b", 7, "a", 9]
x = a[:]
y = a[:]
z = a[:]
zz = a[:]
c = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
c = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
x[::-1] = c
y[9:-11:-1] = c
z[9::-1] = c
zz[11:-13:-1] = c # slice indexes will be truncated to bounds
assert x == ['j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
zz[11:-13:-1] = c # slice indexes will be truncated to bounds
assert x == ["j", "i", "h", "g", "f", "e", "d", "c", "b", "a"]
assert x == y
assert x == z
assert x == zz
# step size bigger than len
x = a[:]
x[::200] = ['a']
assert x == ['a', 1, 2, 3, 4, 5, 6, 7, 8, 9]
x[::200] = ["a"]
assert x == ["a", 1, 2, 3, 4, 5, 6, 7, 8, 9]
x = a[:]
x[5::200] = ['a']
assert x == [0, 1, 2, 3, 4, 'a', 6, 7, 8, 9]
x[5::200] = ["a"]
assert x == [0, 1, 2, 3, 4, "a", 6, 7, 8, 9]
# bad stepped slices
def stepped_slice_assign_too_big():
x = [0, 1, 2, 3, 4]
x[::2] = ['a', 'b', 'c', 'd']
x = [0, 1, 2, 3, 4]
x[::2] = ["a", "b", "c", "d"]
assert_raises(ValueError, stepped_slice_assign_too_big)
def stepped_slice_assign_too_small():
x = [0, 1, 2, 3, 4]
x[::2] = ['a', 'b']
x = [0, 1, 2, 3, 4]
x[::2] = ["a", "b"]
assert_raises(ValueError, stepped_slice_assign_too_small)
# must assign iter t0 slice
def must_assign_iter_to_slice():
x = [0, 1, 2, 3, 4]
x[::2] = 42
x = [0, 1, 2, 3, 4]
x[::2] = 42
assert_raises(TypeError, must_assign_iter_to_slice)
@@ -446,74 +534,87 @@ a = list(range(10))
# string
x = a[:]
x[3:8] = "abcdefghi"
assert x == [0, 1, 2, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 8, 9]
assert x == [0, 1, 2, "a", "b", "c", "d", "e", "f", "g", "h", "i", 8, 9]
# tuple
x = a[:]
x[3:8] = (11, 12, 13, 14, 15)
assert x == [0, 1, 2, 11, 12, 13, 14, 15, 8, 9]
# class
# __next__
class CIterNext:
def __init__(self, sec=(1, 2, 3)):
self.sec = sec
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.sec):
raise StopIteration
v = self.sec[self.index]
self.index += 1
return v
def __init__(self, sec=(1, 2, 3)):
self.sec = sec
self.index = 0
def __iter__(self):
return self
def __next__(self):
if self.index >= len(self.sec):
raise StopIteration
v = self.sec[self.index]
self.index += 1
return v
x = list(range(10))
x[3:8] = CIterNext()
assert x == [0, 1, 2, 1, 2, 3, 8, 9]
# __iter__ yield
class CIter:
def __init__(self, sec=(1, 2, 3)):
self.sec = sec
def __iter__(self):
for n in self.sec:
yield n
def __init__(self, sec=(1, 2, 3)):
self.sec = sec
def __iter__(self):
for n in self.sec:
yield n
x = list(range(10))
x[3:8] = CIter()
assert x == [0, 1, 2, 1, 2, 3, 8, 9]
# __getitem but no __iter__ sequence
class CGetItem:
def __init__(self, sec=(1, 2, 3)):
self.sec = sec
def __getitem__(self, sub):
return self.sec[sub]
def __init__(self, sec=(1, 2, 3)):
self.sec = sec
def __getitem__(self, sub):
return self.sec[sub]
x = list(range(10))
x[3:8] = CGetItem()
assert x == [0, 1, 2, 1, 2, 3, 8, 9]
# iter raises error
class CIterError:
def __iter__(self):
for i in range(10):
if i > 5:
raise RuntimeError
yield i
def __iter__(self):
for i in range(10):
if i > 5:
raise RuntimeError
yield i
def bad_iter_assign():
x = list(range(10))
x[3:8] = CIterError()
x = list(range(10))
x[3:8] = CIterError()
assert_raises(RuntimeError, bad_iter_assign)
# slice assign when step or stop is -1
a = list(range(10))
x = a[:]
x[-1:-5:-1] = ['a', 'b', 'c', 'd']
assert x == [0, 1, 2, 3, 4, 5, 'd', 'c', 'b', 'a']
x[-1:-5:-1] = ["a", "b", "c", "d"]
assert x == [0, 1, 2, 3, 4, 5, "d", "c", "b", "a"]
x = a[:]
x[-5:-1:-1] = []
assert x == [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
@@ -557,17 +658,17 @@ assert [0, 0] <= [0, 0]
assert not [0, 0] > [0, 0]
assert not [0, 0] < [0, 0]
assert not [float('nan'), float('nan')] <= [float('nan'), 1]
assert not [float('nan'), float('nan')] <= [float('nan'), float('nan')]
assert not [float('nan'), float('nan')] >= [float('nan'), float('nan')]
assert not [float('nan'), float('nan')] < [float('nan'), float('nan')]
assert not [float('nan'), float('nan')] > [float('nan'), float('nan')]
assert not [float("nan"), float("nan")] <= [float("nan"), 1]
assert not [float("nan"), float("nan")] <= [float("nan"), float("nan")]
assert not [float("nan"), float("nan")] >= [float("nan"), float("nan")]
assert not [float("nan"), float("nan")] < [float("nan"), float("nan")]
assert not [float("nan"), float("nan")] > [float("nan"), float("nan")]
assert [float('inf'), float('inf')] >= [float('inf'), 1]
assert [float('inf'), float('inf')] <= [float('inf'), float('inf')]
assert [float('inf'), float('inf')] >= [float('inf'), float('inf')]
assert not [float('inf'), float('inf')] < [float('inf'), float('inf')]
assert not [float('inf'), float('inf')] > [float('inf'), float('inf')]
assert [float("inf"), float("inf")] >= [float("inf"), 1]
assert [float("inf"), float("inf")] <= [float("inf"), float("inf")]
assert [float("inf"), float("inf")] >= [float("inf"), float("inf")]
assert not [float("inf"), float("inf")] < [float("inf"), float("inf")]
assert not [float("inf"), float("inf")] > [float("inf"), float("inf")]
# list __iadd__
a = []
@@ -575,62 +676,111 @@ a += [1, 2, 3]
assert a == [1, 2, 3]
a = []
a += (1,2,3,4)
a += (1, 2, 3, 4)
assert a == [1, 2, 3, 4]
a += 'abcdefg'
assert a == [1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e', 'f', 'g']
a += "abcdefg"
assert a == [1, 2, 3, 4, "a", "b", "c", "d", "e", "f", "g"]
a += range(10)
assert a == [1, 2, 3, 4, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
assert a == [
1,
2,
3,
4,
"a",
"b",
"c",
"d",
"e",
"f",
"g",
0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
]
a = []
a += {1,2,3,4}
a += {1, 2, 3, 4}
assert a == [1, 2, 3, 4]
a += {'a': 1, 'b': 2, 'z': 51}
assert a == [1, 2, 3, 4, 'a', 'b', 'z']
a += {"a": 1, "b": 2, "z": 51}
assert a == [1, 2, 3, 4, "a", "b", "z"]
class Iter:
def __iter__(self):
yield 12
yield 28
a += Iter()
assert a == [1, 2, 3, 4, 'a', 'b', 'z', 12, 28]
a += bytes(b'hello world')
assert a == [1, 2, 3, 4, 'a', 'b', 'z', 12, 28, 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
a += Iter()
assert a == [1, 2, 3, 4, "a", "b", "z", 12, 28]
a += bytes(b"hello world")
assert a == [
1,
2,
3,
4,
"a",
"b",
"z",
12,
28,
104,
101,
108,
108,
111,
32,
119,
111,
114,
108,
100,
]
class Next:
def __next__(self):
yield 12
yield 28
def iadd_int():
a = []
a += 3
def iadd_slice():
a = []
a += slice(0, 10, 1)
assert_raises(TypeError, iadd_int)
assert_raises(TypeError, iadd_slice)
it = iter([1,2,3,4])
it = iter([1, 2, 3, 4])
assert it.__length_hint__() == 4
assert next(it) == 1
assert it.__length_hint__() == 3
assert list(it) == [2,3,4]
assert list(it) == [2, 3, 4]
assert it.__length_hint__() == 0
it = reversed([1,2,3,4])
it = reversed([1, 2, 3, 4])
assert it.__length_hint__() == 4
assert next(it) == 4
assert it.__length_hint__() == 3
assert list(it) == [3,2,1]
assert list(it) == [3, 2, 1]
assert it.__length_hint__() == 0
a = [*[1, 2], 3, *[4, 5]]
@@ -648,21 +798,25 @@ for base in object, list, tuple:
class C(base):
def __iter__(self):
a.append(2)
def inner():
yield 3
a.append(4)
return inner()
a = [1]
b = [*a, *C(), *a.copy()]
assert b == [1, 3, 1, 2, 4]
# Test for list entering daedlock or not (https://github.com/RustPython/RustPython/pull/2933)
class MutatingCompare:
def __eq__(self, other):
self.list.pop()
return True
m = MutatingCompare()
l = [1, 2, 3, m, 4]
@@ -675,18 +829,21 @@ assert l.index(4) == 3
l = [1, 2, 3, m, 4]
m.list = l
l.remove(4)
assert_raises(ValueError, lambda: l.index(4)) # element 4 must not be in the list
l.remove(4)
assert_raises(ValueError, lambda: l.index(4)) # element 4 must not be in the list
# Test no panic occurred when list elements was deleted in __eq__
class rewrite_list_eq(list):
pass
class poc:
def __eq__(self, other):
list1.clear()
return self
list1 = rewrite_list_eq([poc()])
list1.remove(list1)
assert list1 == []
extra_tests/snippets/builtin_locals.py
+9 -10
View File
@@ -1,19 +1,18 @@
a = 5
b = 6
loc = locals()
assert loc['a'] == 5
assert loc['b'] == 6
assert loc["a"] == 5
assert loc["b"] == 6
def f():
c = 4
a = 7
c = 4
a = 7
loc = locals()
assert loc['a'] == 4
assert loc['c'] == 7
assert not 'b' in loc
loc = locals()
assert loc["a"] == 4
assert loc["c"] == 7
assert not "b" in loc
extra_tests/snippets/builtin_map.py
+2 -2
View File
@@ -1,5 +1,5 @@
a = list(map(str, [1, 2, 3]))
assert a == ['1', '2', '3']
assert a == ["1", "2", "3"]
b = list(map(lambda x, y: x + y, [1, 2, 4], [3, 5]))
@@ -20,7 +20,7 @@ class Counter(object):
return self
it = map(lambda x: x+1, Counter())
it = map(lambda x: x + 1, Counter())
assert next(it) == 2
assert next(it) == 3
extra_tests/snippets/builtin_mappingproxy.py
+6 -5
View File
@@ -1,5 +1,6 @@
from testutils import assert_raises
class A(dict):
def a():
pass
@@ -8,16 +9,16 @@ class A(dict):
pass
assert A.__dict__['a'] == A.a
assert A.__dict__["a"] == A.a
with assert_raises(KeyError) as cm:
A.__dict__['not here']
A.__dict__["not here"]
assert cm.exception.args[0] == "not here"
assert 'b' in A.__dict__
assert 'c' not in A.__dict__
assert "b" in A.__dict__
assert "c" not in A.__dict__
assert '__dict__' in A.__dict__
assert "__dict__" in A.__dict__
assert A.__dict__.get("not here", "default") == "default"
assert A.__dict__.get("a", "default") is A.a
extra_tests/snippets/builtin_max.py
+12 -7
View File
@@ -3,17 +3,22 @@ from testutils import assert_raises
# simple values
assert max(0, 0) == 0
assert max(1, 0) == 1
assert max(1., 0.) == 1.
assert max(1.0, 0.0) == 1.0
assert max(-1, 0) == 0
assert max(1, 2, 3) == 3
# iterables
assert max([1, 2, 3]) == 3
assert max((1, 2, 3)) == 3
assert max({
"a": 0,
"b": 1,
}) == "b"
assert (
max(
{
"a": 0,
"b": 1,
}
)
== "b"
)
assert max([1, 2], default=0) == 2
assert max([], default=0) == 0
assert_raises(ValueError, max, [])
@@ -30,7 +35,7 @@ assert_raises(TypeError, max, 1)
# custom class
class MyComparable():
class MyComparable:
nb = 0
def __init__(self):
@@ -47,7 +52,7 @@ assert max(first, second) == second
assert max([first, second]) == second
class MyNotComparable():
class MyNotComparable:
pass
extra_tests/snippets/builtin_memoryview.py
+42 -35
View File
@@ -10,48 +10,52 @@ assert a[2:3] == b"c"
assert hash(obj) == hash(a)
class A(array.array):
...
class B(bytes):
...
class A(array.array): ...
class C():
...
memoryview(bytearray('abcde', encoding='utf-8'))
memoryview(array.array('i', [1, 2, 3]))
memoryview(A('b', [0]))
memoryview(B('abcde', encoding='utf-8'))
class B(bytes): ...
class C: ...
memoryview(bytearray("abcde", encoding="utf-8"))
memoryview(array.array("i", [1, 2, 3]))
memoryview(A("b", [0]))
memoryview(B("abcde", encoding="utf-8"))
assert_raises(TypeError, lambda: memoryview([1, 2, 3]))
assert_raises(TypeError, lambda: memoryview((1, 2, 3)))
assert_raises(TypeError, lambda: memoryview({}))
assert_raises(TypeError, lambda: memoryview('string'))
assert_raises(TypeError, lambda: memoryview("string"))
assert_raises(TypeError, lambda: memoryview(C()))
def test_slice():
b = b'123456789'
b = b"123456789"
m = memoryview(b)
m2 = memoryview(b)
assert m == m
assert m == m2
assert m.tobytes() == b'123456789'
assert m.tobytes() == b"123456789"
assert m == b
assert m[::2].tobytes() == b'13579'
assert m[::2] == b'13579'
assert m[1::2].tobytes() == b'2468'
assert m[::2][1:].tobytes() == b'3579'
assert m[::2][1:-1].tobytes() == b'357'
assert m[::2][::2].tobytes() == b'159'
assert m[::2][1::2].tobytes() == b'37'
assert m[::-1].tobytes() == b'987654321'
assert m[::-2].tobytes() == b'97531'
assert m[::2].tobytes() == b"13579"
assert m[::2] == b"13579"
assert m[1::2].tobytes() == b"2468"
assert m[::2][1:].tobytes() == b"3579"
assert m[::2][1:-1].tobytes() == b"357"
assert m[::2][::2].tobytes() == b"159"
assert m[::2][1::2].tobytes() == b"37"
assert m[::-1].tobytes() == b"987654321"
assert m[::-2].tobytes() == b"97531"
test_slice()
def test_resizable():
b = bytearray(b'123')
b = bytearray(b"123")
b.append(4)
m = memoryview(b)
assert_raises(BufferError, lambda: b.append(5))
@@ -68,18 +72,21 @@ def test_resizable():
m4.release()
b.append(7)
test_resizable()
def test_delitem():
a = b'abc'
b = memoryview(a)
assert_raises(TypeError, lambda : b.__delitem__())
assert_raises(TypeError, lambda : b.__delitem__(0))
assert_raises(TypeError, lambda : b.__delitem__(10))
a = bytearray(b'abc')
b = memoryview(a)
assert_raises(TypeError, lambda : b.__delitem__())
assert_raises(TypeError, lambda : b.__delitem__(1))
assert_raises(TypeError, lambda : b.__delitem__(12))
test_delitem()
def test_delitem():
a = b"abc"
b = memoryview(a)
assert_raises(TypeError, lambda: b.__delitem__())
assert_raises(TypeError, lambda: b.__delitem__(0))
assert_raises(TypeError, lambda: b.__delitem__(10))
a = bytearray(b"abc")
b = memoryview(a)
assert_raises(TypeError, lambda: b.__delitem__())
assert_raises(TypeError, lambda: b.__delitem__(1))
assert_raises(TypeError, lambda: b.__delitem__(12))
test_delitem()
extra_tests/snippets/builtin_min.py
+12 -7
View File
@@ -3,17 +3,22 @@ from testutils import assert_raises
# simple values
assert min(0, 0) == 0
assert min(1, 0) == 0
assert min(1., 0.) == 0.
assert min(1.0, 0.0) == 0.0
assert min(-1, 0) == -1
assert min(1, 2, 3) == 1
# iterables
assert min([1, 2, 3]) == 1
assert min((1, 2, 3)) == 1
assert min({
"a": 0,
"b": 1,
}) == "a"
assert (
min(
{
"a": 0,
"b": 1,
}
)
== "a"
)
assert min([1, 2], default=0) == 1
assert min([], default=0) == 0
@@ -31,7 +36,7 @@ assert_raises(TypeError, min, 1)
# custom class
class MyComparable():
class MyComparable:
nb = 0
def __init__(self):
@@ -48,7 +53,7 @@ assert min(first, second) == first
assert min([first, second]) == first
class MyNotComparable():
class MyNotComparable:
pass
extra_tests/snippets/builtin_none.py
+5 -2
View File
@@ -4,19 +4,22 @@ y = None
x = None
assert x is y
def none():
pass
def none2():
return None
assert none() is none()
assert none() is x
assert none() is none2()
assert str(None) == 'None'
assert repr(None) == 'None'
assert str(None) == "None"
assert repr(None) == "None"
assert type(None)() is None
assert None.__eq__(3) is NotImplemented
extra_tests/snippets/builtin_object.py
+3 -2
View File
@@ -1,6 +1,7 @@
class MyObject:
pass
assert not MyObject() == MyObject()
assert MyObject() != MyObject()
myobj = MyObject()
@@ -21,8 +22,8 @@ obj = MyObject()
assert obj.__eq__(obj) is True
assert obj.__ne__(obj) is False
assert not hasattr(obj, 'a')
obj.__dict__ = {'a': 1}
assert not hasattr(obj, "a")
obj.__dict__ = {"a": 1}
assert obj.a == 1
# Value inside the formatter goes through a different path of resolution.
extra_tests/snippets/builtin_open.py
+6 -6
View File
@@ -1,19 +1,19 @@
from testutils import assert_raises
fd = open('README.md')
assert 'RustPython' in fd.read()
fd = open("README.md")
assert "RustPython" in fd.read()
assert_raises(FileNotFoundError, open, 'DoesNotExist')
assert_raises(FileNotFoundError, open, "DoesNotExist")
# Use open as a context manager
with open('README.md', 'rt') as fp:
with open("README.md", "rt") as fp:
contents = fp.read()
assert type(contents) == str, "type is " + str(type(contents))
with open('README.md', 'r') as fp:
with open("README.md", "r") as fp:
contents = fp.read()
assert type(contents) == str, "type is " + str(type(contents))
with open('README.md', 'rb') as fp:
with open("README.md", "rb") as fp:
contents = fp.read()
assert type(contents) == bytes, "type is " + str(type(contents))
extra_tests/snippets/builtin_ord.py
+14 -7
View File
@@ -3,11 +3,18 @@ from testutils import assert_raises
assert ord("a") == 97
assert ord("é") == 233
assert ord("🤡") == 129313
assert ord(b'a') == 97
assert ord(bytearray(b'a')) == 97
assert ord(b"a") == 97
assert ord(bytearray(b"a")) == 97
assert_raises(TypeError, ord, _msg='ord() is called with no argument')
assert_raises(TypeError, ord, "", _msg='ord() is called with an empty string')
assert_raises(TypeError, ord, "ab", _msg='ord() is called with more than one character')
assert_raises(TypeError, ord, b"ab", _msg='ord() expected a character, but string of length 2 found')
assert_raises(TypeError, ord, 1, _msg='ord() expected a string, bytes or bytearray, but found int')
assert_raises(TypeError, ord, _msg="ord() is called with no argument")
assert_raises(TypeError, ord, "", _msg="ord() is called with an empty string")
assert_raises(TypeError, ord, "ab", _msg="ord() is called with more than one character")
assert_raises(
TypeError,
ord,
b"ab",
_msg="ord() expected a character, but string of length 2 found",
)
assert_raises(
TypeError, ord, 1, _msg="ord() expected a string, bytes or bytearray, but found int"
)
extra_tests/snippets/builtin_pow.py
+22 -30
View File
@@ -12,7 +12,7 @@ assert pow(1, 2.0) == 1.0
assert pow(2.0, 1) == 2.0
assert pow(0, 10**1000) == 0
assert pow(1, 10**1000) == 1
assert pow(-1, 10**1000+1) == -1
assert pow(-1, 10**1000 + 1) == -1
assert pow(-1, 10**1000) == 1
assert pow(2, 4, 5) == 1
@@ -59,7 +59,7 @@ def powtest(type):
assert_raises(ZeroDivisionError, pow, zero, exp)
il, ih = -20, 20
jl, jh = -5, 5
jl, jh = -5, 5
kl, kh = -10, 10
asseq = assert_equal
if type == float:
@@ -76,10 +76,7 @@ def powtest(type):
if type == float or j < 0:
assert_raises(TypeError, pow, type(i), j, k)
continue
asseq(
pow(type(i), j, k),
pow(type(i), j) % type(k)
)
asseq(pow(type(i), j, k), pow(type(i), j) % type(k))
def test_powint():
@@ -92,40 +89,35 @@ def test_powfloat():
def test_other():
# Other tests-- not very systematic
assert_equal(pow(3,3) % 8, pow(3,3,8))
assert_equal(pow(3,3) % -8, pow(3,3,-8))
assert_equal(pow(3,2) % -2, pow(3,2,-2))
assert_equal(pow(-3,3) % 8, pow(-3,3,8))
assert_equal(pow(-3,3) % -8, pow(-3,3,-8))
assert_equal(pow(5,2) % -8, pow(5,2,-8))
assert_equal(pow(3, 3) % 8, pow(3, 3, 8))
assert_equal(pow(3, 3) % -8, pow(3, 3, -8))
assert_equal(pow(3, 2) % -2, pow(3, 2, -2))
assert_equal(pow(-3, 3) % 8, pow(-3, 3, 8))
assert_equal(pow(-3, 3) % -8, pow(-3, 3, -8))
assert_equal(pow(5, 2) % -8, pow(5, 2, -8))
assert_equal(pow(3,3) % 8, pow(3,3,8))
assert_equal(pow(3,3) % -8, pow(3,3,-8))
assert_equal(pow(3,2) % -2, pow(3,2,-2))
assert_equal(pow(-3,3) % 8, pow(-3,3,8))
assert_equal(pow(-3,3) % -8, pow(-3,3,-8))
assert_equal(pow(5,2) % -8, pow(5,2,-8))
assert_equal(pow(3, 3) % 8, pow(3, 3, 8))
assert_equal(pow(3, 3) % -8, pow(3, 3, -8))
assert_equal(pow(3, 2) % -2, pow(3, 2, -2))
assert_equal(pow(-3, 3) % 8, pow(-3, 3, 8))
assert_equal(pow(-3, 3) % -8, pow(-3, 3, -8))
assert_equal(pow(5, 2) % -8, pow(5, 2, -8))
for i in range(-10, 11):
for j in range(0, 6):
for k in range(-7, 11):
if j >= 0 and k != 0:
assert_equal(
pow(i,j) % k,
pow(i,j,k)
)
assert_equal(pow(i, j) % k, pow(i, j, k))
if j >= 0 and k != 0:
assert_equal(
pow(int(i),j) % k,
pow(int(i),j,k)
)
assert_equal(pow(int(i), j) % k, pow(int(i), j, k))
def test_bug643260():
class TestRpow:
def __rpow__(self, other):
return None
None ** TestRpow() # Won't fail when __rpow__ invoked. SF bug #643260.
None ** TestRpow() # Won't fail when __rpow__ invoked. SF bug #643260.
def test_bug705231():
@@ -141,15 +133,15 @@ def test_bug705231():
for b in range(-10, 11):
eq(pow(a, float(b)), b & 1 and -1.0 or 1.0)
for n in range(0, 100):
fiveto = float(5 ** n)
fiveto = float(5**n)
# For small n, fiveto will be odd. Eventually we run out of
# mantissa bits, though, and thereafer fiveto will be even.
expected = fiveto % 2.0 and -1.0 or 1.0
eq(pow(a, fiveto), expected)
eq(pow(a, -fiveto), expected)
eq(expected, 1.0) # else we didn't push fiveto to evenness
eq(expected, 1.0) # else we didn't push fiveto to evenness
tests = [f for name, f in locals().items() if name.startswith('test_')]
tests = [f for name, f in locals().items() if name.startswith("test_")]
for f in tests:
f()
extra_tests/snippets/builtin_print.py
+6 -6
View File
@@ -3,14 +3,14 @@ import io
print(2 + 3)
assert_raises(TypeError, print, 'test', end=4, _msg='wrong type passed to end')
assert_raises(TypeError, print, 'test', sep=['a'], _msg='wrong type passed to sep')
assert_raises(TypeError, print, "test", end=4, _msg="wrong type passed to end")
assert_raises(TypeError, print, "test", sep=["a"], _msg="wrong type passed to sep")
try:
print('test', end=None, sep=None, flush=None)
print("test", end=None, sep=None, flush=None)
except:
assert False, 'Expected None passed to end, sep, and flush to not raise errors'
assert False, "Expected None passed to end, sep, and flush to not raise errors"
buf = io.StringIO()
print('hello, world', file=buf)
assert buf.getvalue() == 'hello, world\n', buf.getvalue()
print("hello, world", file=buf)
assert buf.getvalue() == "hello, world\n", buf.getvalue()
extra_tests/snippets/builtin_property.py
+3 -3
View File
@@ -62,8 +62,8 @@ with assert_raises(TypeError):
assert p.__doc__ is None
# Test property instance __doc__ attribute:
p.__doc__ = '222'
assert p.__doc__ == '222'
p.__doc__ = "222"
assert p.__doc__ == "222"
p1 = property("a", "b", "c")
@@ -83,5 +83,5 @@ assert p1.deleter(None).fdel == "c"
assert p1.__get__(None, object) is p1
# assert p1.__doc__ is 'a'.__doc__
p2 = property('a', doc='pdoc')
p2 = property("a", doc="pdoc")
# assert p2.__doc__ == 'pdoc'
extra_tests/snippets/builtin_range.py
+24 -20
View File
@@ -1,11 +1,11 @@
from testutils import assert_raises
assert range(2**63+1)[2**63] == 9223372036854775808
assert range(2**63 + 1)[2**63] == 9223372036854775808
# len tests
assert len(range(10, 5)) == 0, 'Range with no elements should have length = 0'
assert len(range(10, 5, -2)) == 3, 'Expected length 3, for elements: 10, 8, 6'
assert len(range(5, 10, 2)) == 3, 'Expected length 3, for elements: 5, 7, 9'
assert len(range(10, 5)) == 0, "Range with no elements should have length = 0"
assert len(range(10, 5, -2)) == 3, "Expected length 3, for elements: 10, 8, 6"
assert len(range(5, 10, 2)) == 3, "Expected length 3, for elements: 5, 7, 9"
# index tests
assert range(10).index(6) == 6
@@ -13,18 +13,18 @@ assert range(4, 10).index(6) == 2
assert range(4, 10, 2).index(6) == 1
assert range(10, 4, -2).index(8) == 1
assert_raises(ValueError, lambda: range(10).index(-1), _msg='out of bounds')
assert_raises(ValueError, lambda: range(10).index(10), _msg='out of bounds')
assert_raises(ValueError, lambda: range(4, 10, 2).index(5), _msg='out of step')
assert_raises(ValueError, lambda: range(10).index('foo'), _msg='not an int')
assert_raises(ValueError, lambda: range(1, 10, 0), _msg='step is zero')
assert_raises(ValueError, lambda: range(10).index(-1), _msg="out of bounds")
assert_raises(ValueError, lambda: range(10).index(10), _msg="out of bounds")
assert_raises(ValueError, lambda: range(4, 10, 2).index(5), _msg="out of step")
assert_raises(ValueError, lambda: range(10).index("foo"), _msg="not an int")
assert_raises(ValueError, lambda: range(1, 10, 0), _msg="step is zero")
# get tests
assert range(10)[0] == 0
assert range(10)[9] == 9
assert range(10, 0, -1)[0] == 10
assert range(10, 0, -1)[9] == 1
assert_raises(IndexError, lambda: range(10)[10], _msg='out of bound')
assert_raises(IndexError, lambda: range(10)[10], _msg="out of bound")
# slice tests
assert range(10)[0:3] == range(3)
@@ -34,13 +34,17 @@ assert range(10)[-15:3] == range(0, 3)
assert range(10, 100, 3)[4:1000:5] == range(22, 100, 15)
assert range(10)[:] == range(10)
assert range(10, 0, -2)[0:5:2] == range(10, 0, -4)
assert range(10)[10:11] == range(10,10)
assert range(10)[10:11] == range(10, 10)
assert range(0, 10, -1)[::-1] == range(1, 1)
assert range(0, 10)[::-1] == range(9, -1, -1)
assert range(0, -10)[::-1] == range(-1, -1, -1)
assert range(0, -10)[::-1][::-1] == range(0, 0)
assert_raises(ValueError, lambda: range(0, 10)[::0], _msg='slice step cannot be zero')
assert_raises(TypeError, lambda: range(0, 10)['a':], _msg='slice indices must be integers or None or have an __index__ method')
assert_raises(ValueError, lambda: range(0, 10)[::0], _msg="slice step cannot be zero")
assert_raises(
TypeError,
lambda: range(0, 10)["a":],
_msg="slice indices must be integers or None or have an __index__ method",
)
# count tests
assert range(10).count(2) == 1
@@ -64,22 +68,22 @@ assert range(10).__eq__(range(0, 11, 1)) is False
assert range(10).__ne__(range(0, 11, 1)) is True
assert range(0, 10, 3).__eq__(range(0, 11, 3)) is True
assert range(0, 10, 3).__ne__(range(0, 11, 3)) is False
#__lt__
# __lt__
assert range(1, 2, 3).__lt__(range(1, 2, 3)) == NotImplemented
assert range(1, 2, 1).__lt__(range(1, 2)) == NotImplemented
assert range(2).__lt__(range(0, 2)) == NotImplemented
#__gt__
# __gt__
assert range(1, 2, 3).__gt__(range(1, 2, 3)) == NotImplemented
assert range(1, 2, 1).__gt__(range(1, 2)) == NotImplemented
assert range(2).__gt__(range(0, 2)) == NotImplemented
#__le__
# __le__
assert range(1, 2, 3).__le__(range(1, 2, 3)) == NotImplemented
assert range(1, 2, 1).__le__(range(1, 2)) == NotImplemented
assert range(2).__le__(range(0, 2)) == NotImplemented
#__ge__
# __ge__
assert range(1, 2, 3).__ge__(range(1, 2, 3)) == NotImplemented
assert range(1, 2, 1).__ge__(range(1, 2)) == NotImplemented
assert range(2).__ge__(range(0, 2)) == NotImplemented
@@ -101,12 +105,12 @@ assert 8 in range(10, 4, -2)
assert -1 not in range(10)
assert 9 not in range(10, 4, -2)
assert 4 not in range(10, 4, -2)
assert 'foo' not in range(10)
assert "foo" not in range(10)
# __reversed__
assert list(reversed(range(5))) == [4, 3, 2, 1, 0]
assert list(reversed(range(5, 0, -1))) == [1, 2, 3, 4, 5]
assert list(reversed(range(1,10,5))) == [6, 1]
assert list(reversed(range(1, 10, 5))) == [6, 1]
# __reduce__
assert range(10).__reduce__()[0] == range
@@ -120,7 +124,7 @@ assert range(i).stop is i
# negative index
assert range(10)[-1] == 9
assert_raises(IndexError, lambda: range(10)[-11], _msg='out of bound')
assert_raises(IndexError, lambda: range(10)[-11], _msg="out of bound")
assert range(10)[-2:4] == range(8, 4)
assert range(10)[-6:-2] == range(4, 8)
assert range(50, 0, -2)[-5] == 10
extra_tests/snippets/builtin_reversed.py
+2 -2
View File
@@ -1,4 +1,4 @@
assert list(reversed(range(5))) == [4, 3, 2, 1, 0]
l = [5,4,3,2,1]
assert list(reversed(l)) == [1,2,3,4,5]
l = [5, 4, 3, 2, 1]
assert list(reversed(l)) == [1, 2, 3, 4, 5]
extra_tests/snippets/builtin_round.py
+3 -3
View File
@@ -8,11 +8,11 @@ assert round(-0.5) == 0
assert round(-1.5) == -2
# ValueError: cannot convert float NaN to integer
assert_raises(ValueError, round, float('nan'))
assert_raises(ValueError, round, float("nan"))
# OverflowError: cannot convert float infinity to integer
assert_raises(OverflowError, round, float('inf'))
assert_raises(OverflowError, round, float("inf"))
# OverflowError: cannot convert float infinity to integer
assert_raises(OverflowError, round, -float('inf'))
assert_raises(OverflowError, round, -float("inf"))
assert round(0) == 0
assert isinstance(round(0), int)
extra_tests/snippets/builtin_set.py
+207 -173
View File
@@ -1,38 +1,54 @@
from testutils import assert_raises
assert set([1,2]) == set([1,2])
assert not set([1,2,3]) == set([1,2])
assert set([1, 2]) == set([1, 2])
assert not set([1, 2, 3]) == set([1, 2])
assert set([1,2,3]) >= set([1,2])
assert set([1,2]) >= set([1,2])
assert not set([1,3]) >= set([1,2])
assert set([1, 2, 3]) >= set([1, 2])
assert set([1, 2]) >= set([1, 2])
assert not set([1, 3]) >= set([1, 2])
assert set([1,2,3]).issuperset(set([1,2]))
assert set([1,2]).issuperset(set([1,2]))
assert not set([1,3]).issuperset(set([1,2]))
assert set([1, 2, 3]).issuperset(set([1, 2]))
assert set([1, 2]).issuperset(set([1, 2]))
assert not set([1, 3]).issuperset(set([1, 2]))
assert set([1,2,3]) > set([1,2])
assert not set([1,2]) > set([1,2])
assert not set([1,3]) > set([1,2])
assert set([1, 2, 3]) > set([1, 2])
assert not set([1, 2]) > set([1, 2])
assert not set([1, 3]) > set([1, 2])
assert set([1,2]) <= set([1,2,3])
assert set([1,2]) <= set([1,2])
assert not set([1,3]) <= set([1,2])
assert set([1, 2]) <= set([1, 2, 3])
assert set([1, 2]) <= set([1, 2])
assert not set([1, 3]) <= set([1, 2])
assert set([1,2]).issubset(set([1,2,3]))
assert set([1,2]).issubset(set([1,2]))
assert not set([1,3]).issubset(set([1,2]))
assert set([1, 2]).issubset(set([1, 2, 3]))
assert set([1, 2]).issubset(set([1, 2]))
assert not set([1, 3]).issubset(set([1, 2]))
assert set([1,2]) < set([1,2,3])
assert not set([1,2]) < set([1,2])
assert not set([1,3]) < set([1,2])
assert set([1, 2]) < set([1, 2, 3])
assert not set([1, 2]) < set([1, 2])
assert not set([1, 3]) < set([1, 2])
assert (set() == []) is False
assert set().__eq__([]) == NotImplemented
assert_raises(TypeError, lambda: set() < [], _msg="'<' not supported between instances of 'set' and 'list'")
assert_raises(TypeError, lambda: set() <= [], _msg="'<=' not supported between instances of 'set' and 'list'")
assert_raises(TypeError, lambda: set() > [], _msg="'>' not supported between instances of 'set' and 'list'")
assert_raises(TypeError, lambda: set() >= [], _msg="'>=' not supported between instances of 'set' and 'list'")
assert_raises(
TypeError,
lambda: set() < [],
_msg="'<' not supported between instances of 'set' and 'list'",
)
assert_raises(
TypeError,
lambda: set() <= [],
_msg="'<=' not supported between instances of 'set' and 'list'",
)
assert_raises(
TypeError,
lambda: set() > [],
_msg="'>' not supported between instances of 'set' and 'list'",
)
assert_raises(
TypeError,
lambda: set() >= [],
_msg="'>=' not supported between instances of 'set' and 'list'",
)
assert set().issuperset([])
assert set().issubset([])
assert not set().issuperset([1, 2, 3])
@@ -47,6 +63,7 @@ assert_raises(TypeError, lambda: set() >= 3, _msg="'int' object is not iterable"
assert_raises(TypeError, set().issuperset, 3, _msg="'int' object is not iterable")
assert_raises(TypeError, set().issubset, 3, _msg="'int' object is not iterable")
class Hashable(object):
def __init__(self, obj):
self.obj = obj
@@ -57,6 +74,7 @@ class Hashable(object):
def __hash__(self):
return id(self)
assert repr(set()) == "set()"
assert repr(set([1, 2, 3])) == "{1, 2, 3}"
@@ -64,9 +82,11 @@ recursive = set()
recursive.add(Hashable(recursive))
assert repr(recursive) == "{set(...)}"
class S(set):
pass
assert repr(S()) == "S()"
assert repr(S([1, 2, 3])) == "S({1, 2, 3})"
@@ -79,44 +99,44 @@ assert len(a) == 3
a.clear()
assert len(a) == 0
assert set([1,2,3]).union(set([4,5])) == set([1,2,3,4,5])
assert set([1,2,3]).union(set([1,2,3,4,5])) == set([1,2,3,4,5])
assert set([1,2,3]).union([1,2,3,4,5]) == set([1,2,3,4,5])
assert set([1, 2, 3]).union(set([4, 5])) == set([1, 2, 3, 4, 5])
assert set([1, 2, 3]).union(set([1, 2, 3, 4, 5])) == set([1, 2, 3, 4, 5])
assert set([1, 2, 3]).union([1, 2, 3, 4, 5]) == set([1, 2, 3, 4, 5])
assert set([1,2,3]) | set([4,5]) == set([1,2,3,4,5])
assert set([1,2,3]) | set([1,2,3,4,5]) == set([1,2,3,4,5])
assert_raises(TypeError, lambda: set([1,2,3]) | [1,2,3,4,5])
assert set([1, 2, 3]) | set([4, 5]) == set([1, 2, 3, 4, 5])
assert set([1, 2, 3]) | set([1, 2, 3, 4, 5]) == set([1, 2, 3, 4, 5])
assert_raises(TypeError, lambda: set([1, 2, 3]) | [1, 2, 3, 4, 5])
assert set([1,2,3]).intersection(set([1,2])) == set([1,2])
assert set([1,2,3]).intersection(set([5,6])) == set([])
assert set([1,2,3]).intersection([1,2]) == set([1,2])
assert set([1, 2, 3]).intersection(set([1, 2])) == set([1, 2])
assert set([1, 2, 3]).intersection(set([5, 6])) == set([])
assert set([1, 2, 3]).intersection([1, 2]) == set([1, 2])
assert set([1,2,3]) & set([4,5]) == set([])
assert set([1,2,3]) & set([1,2,3,4,5]) == set([1,2,3])
assert_raises(TypeError, lambda: set([1,2,3]) & [1,2,3,4,5])
assert set([1, 2, 3]) & set([4, 5]) == set([])
assert set([1, 2, 3]) & set([1, 2, 3, 4, 5]) == set([1, 2, 3])
assert_raises(TypeError, lambda: set([1, 2, 3]) & [1, 2, 3, 4, 5])
assert set([1,2,3]).difference(set([1,2])) == set([3])
assert set([1,2,3]).difference(set([5,6])) == set([1,2,3])
assert set([1,2,3]).difference([1,2]) == set([3])
assert set([1, 2, 3]).difference(set([1, 2])) == set([3])
assert set([1, 2, 3]).difference(set([5, 6])) == set([1, 2, 3])
assert set([1, 2, 3]).difference([1, 2]) == set([3])
assert set([1,2,3]) - set([4,5]) == set([1,2,3])
assert set([1,2,3]) - set([1,2,3,4,5]) == set([])
assert_raises(TypeError, lambda: set([1,2,3]) - [1,2,3,4,5])
assert set([1, 2, 3]) - set([4, 5]) == set([1, 2, 3])
assert set([1, 2, 3]) - set([1, 2, 3, 4, 5]) == set([])
assert_raises(TypeError, lambda: set([1, 2, 3]) - [1, 2, 3, 4, 5])
assert set([1,2]).__sub__(set([2,3])) == set([1])
assert set([1,2]).__rsub__(set([2,3])) == set([3])
assert set([1, 2]).__sub__(set([2, 3])) == set([1])
assert set([1, 2]).__rsub__(set([2, 3])) == set([3])
assert set([1,2,3]).symmetric_difference(set([1,2])) == set([3])
assert set([1,2,3]).symmetric_difference(set([5,6])) == set([1,2,3,5,6])
assert set([1,2,3]).symmetric_difference([1,2]) == set([3])
assert set([1, 2, 3]).symmetric_difference(set([1, 2])) == set([3])
assert set([1, 2, 3]).symmetric_difference(set([5, 6])) == set([1, 2, 3, 5, 6])
assert set([1, 2, 3]).symmetric_difference([1, 2]) == set([3])
assert set([1,2,3]) ^ set([4,5]) == set([1,2,3,4,5])
assert set([1,2,3]) ^ set([1,2,3,4,5]) == set([4,5])
assert_raises(TypeError, lambda: set([1,2,3]) ^ [1,2,3,4,5])
assert set([1, 2, 3]) ^ set([4, 5]) == set([1, 2, 3, 4, 5])
assert set([1, 2, 3]) ^ set([1, 2, 3, 4, 5]) == set([4, 5])
assert_raises(TypeError, lambda: set([1, 2, 3]) ^ [1, 2, 3, 4, 5])
assert set([1,2,3]).isdisjoint(set([5,6])) == True
assert set([1,2,3]).isdisjoint(set([2,5,6])) == False
assert set([1,2,3]).isdisjoint([5,6]) == True
assert set([1, 2, 3]).isdisjoint(set([5, 6])) == True
assert set([1, 2, 3]).isdisjoint(set([2, 5, 6])) == False
assert set([1, 2, 3]).isdisjoint([5, 6]) == True
assert_raises(TypeError, lambda: set() & [])
assert_raises(TypeError, lambda: set() | [])
@@ -132,7 +152,7 @@ assert a.discard(1) is None
assert not 1 in a
assert a.discard(42) is None
a = set([1,2,3])
a = set([1, 2, 3])
b = a.copy()
assert len(a) == 3
assert len(b) == 3
@@ -140,71 +160,71 @@ b.clear()
assert len(a) == 3
assert len(b) == 0
a = set([1,2])
a = set([1, 2])
b = a.pop()
assert b in [1,2]
assert b in [1, 2]
c = a.pop()
assert (c in [1,2] and c != b)
assert c in [1, 2] and c != b
assert_raises(KeyError, lambda: a.pop())
a = set([1,2,3])
a.update([3,4,5])
assert a == set([1,2,3,4,5])
a = set([1, 2, 3])
a.update([3, 4, 5])
assert a == set([1, 2, 3, 4, 5])
assert_raises(TypeError, lambda: a.update(1))
a = set([1,2,3])
a = set([1, 2, 3])
b = set()
for e in a:
assert e == 1 or e == 2 or e == 3
b.add(e)
assert e == 1 or e == 2 or e == 3
b.add(e)
assert a == b
a = set([1,2,3])
a |= set([3,4,5])
assert a == set([1,2,3,4,5])
a = set([1, 2, 3])
a |= set([3, 4, 5])
assert a == set([1, 2, 3, 4, 5])
with assert_raises(TypeError):
a |= 1
a |= 1
with assert_raises(TypeError):
a |= [1,2,3]
a |= [1, 2, 3]
a = set([1,2,3])
a.intersection_update([2,3,4,5])
assert a == set([2,3])
a = set([1, 2, 3])
a.intersection_update([2, 3, 4, 5])
assert a == set([2, 3])
assert_raises(TypeError, lambda: a.intersection_update(1))
a = set([1,2,3])
a &= set([2,3,4,5])
assert a == set([2,3])
a = set([1, 2, 3])
a &= set([2, 3, 4, 5])
assert a == set([2, 3])
with assert_raises(TypeError):
a &= 1
a &= 1
with assert_raises(TypeError):
a &= [1,2,3]
a &= [1, 2, 3]
a = set([1,2,3])
a.difference_update([3,4,5])
assert a == set([1,2])
a = set([1, 2, 3])
a.difference_update([3, 4, 5])
assert a == set([1, 2])
assert_raises(TypeError, lambda: a.difference_update(1))
a = set([1,2,3])
a -= set([3,4,5])
assert a == set([1,2])
a = set([1, 2, 3])
a -= set([3, 4, 5])
assert a == set([1, 2])
with assert_raises(TypeError):
a -= 1
a -= 1
with assert_raises(TypeError):
a -= [1,2,3]
a -= [1, 2, 3]
a = set([1,2,3])
a.symmetric_difference_update([3,4,5])
assert a == set([1,2,4,5])
a = set([1, 2, 3])
a.symmetric_difference_update([3, 4, 5])
assert a == set([1, 2, 4, 5])
assert_raises(TypeError, lambda: a.difference_update(1))
a = set([1,2,3])
a ^= set([3,4,5])
assert a == set([1,2,4,5])
a = set([1, 2, 3])
a ^= set([3, 4, 5])
assert a == set([1, 2, 4, 5])
with assert_raises(TypeError):
a ^= 1
a ^= 1
with assert_raises(TypeError):
a ^= [1,2,3]
a ^= [1, 2, 3]
a = set([1, 2, 3])
i = iter(a)
@@ -218,142 +238,154 @@ a.remove(4)
# frozen set
assert frozenset([1,2]) == frozenset([1,2])
assert not frozenset([1,2,3]) == frozenset([1,2])
assert frozenset([1, 2]) == frozenset([1, 2])
assert not frozenset([1, 2, 3]) == frozenset([1, 2])
assert frozenset([1,2,3]) >= frozenset([1,2])
assert frozenset([1,2]) >= frozenset([1,2])
assert not frozenset([1,3]) >= frozenset([1,2])
assert frozenset([1, 2, 3]) >= frozenset([1, 2])
assert frozenset([1, 2]) >= frozenset([1, 2])
assert not frozenset([1, 3]) >= frozenset([1, 2])
assert frozenset([1,2,3]).issuperset(frozenset([1,2]))
assert frozenset([1,2]).issuperset(frozenset([1,2]))
assert not frozenset([1,3]).issuperset(frozenset([1,2]))
assert frozenset([1, 2, 3]).issuperset(frozenset([1, 2]))
assert frozenset([1, 2]).issuperset(frozenset([1, 2]))
assert not frozenset([1, 3]).issuperset(frozenset([1, 2]))
assert frozenset([1,2,3]) > frozenset([1,2])
assert not frozenset([1,2]) > frozenset([1,2])
assert not frozenset([1,3]) > frozenset([1,2])
assert frozenset([1, 2, 3]) > frozenset([1, 2])
assert not frozenset([1, 2]) > frozenset([1, 2])
assert not frozenset([1, 3]) > frozenset([1, 2])
assert frozenset([1,2]) <= frozenset([1,2,3])
assert frozenset([1,2]) <= frozenset([1,2])
assert not frozenset([1,3]) <= frozenset([1,2])
assert frozenset([1, 2]) <= frozenset([1, 2, 3])
assert frozenset([1, 2]) <= frozenset([1, 2])
assert not frozenset([1, 3]) <= frozenset([1, 2])
assert frozenset([1,2]).issubset(frozenset([1,2,3]))
assert frozenset([1,2]).issubset(frozenset([1,2]))
assert not frozenset([1,3]).issubset(frozenset([1,2]))
assert frozenset([1, 2]).issubset(frozenset([1, 2, 3]))
assert frozenset([1, 2]).issubset(frozenset([1, 2]))
assert not frozenset([1, 3]).issubset(frozenset([1, 2]))
assert frozenset([1,2]) < frozenset([1,2,3])
assert not frozenset([1,2]) < frozenset([1,2])
assert not frozenset([1,3]) < frozenset([1,2])
assert frozenset([1, 2]) < frozenset([1, 2, 3])
assert not frozenset([1, 2]) < frozenset([1, 2])
assert not frozenset([1, 3]) < frozenset([1, 2])
a = frozenset([1, 2, 3])
assert len(a) == 3
b = a.copy()
assert b == a
assert frozenset([1,2,3]).union(frozenset([4,5])) == frozenset([1,2,3,4,5])
assert frozenset([1,2,3]).union(frozenset([1,2,3,4,5])) == frozenset([1,2,3,4,5])
assert frozenset([1,2,3]).union([1,2,3,4,5]) == frozenset([1,2,3,4,5])
assert frozenset([1, 2, 3]).union(frozenset([4, 5])) == frozenset([1, 2, 3, 4, 5])
assert frozenset([1, 2, 3]).union(frozenset([1, 2, 3, 4, 5])) == frozenset(
[1, 2, 3, 4, 5]
)
assert frozenset([1, 2, 3]).union([1, 2, 3, 4, 5]) == frozenset([1, 2, 3, 4, 5])
assert frozenset([1,2,3]) | frozenset([4,5]) == frozenset([1,2,3,4,5])
assert frozenset([1,2,3]) | frozenset([1,2,3,4,5]) == frozenset([1,2,3,4,5])
assert_raises(TypeError, lambda: frozenset([1,2,3]) | [1,2,3,4,5])
assert frozenset([1, 2, 3]) | frozenset([4, 5]) == frozenset([1, 2, 3, 4, 5])
assert frozenset([1, 2, 3]) | frozenset([1, 2, 3, 4, 5]) == frozenset([1, 2, 3, 4, 5])
assert_raises(TypeError, lambda: frozenset([1, 2, 3]) | [1, 2, 3, 4, 5])
assert frozenset([1,2,3]).intersection(frozenset([1,2])) == frozenset([1,2])
assert frozenset([1,2,3]).intersection(frozenset([5,6])) == frozenset([])
assert frozenset([1,2,3]).intersection([1,2]) == frozenset([1,2])
assert frozenset([1, 2, 3]).intersection(frozenset([1, 2])) == frozenset([1, 2])
assert frozenset([1, 2, 3]).intersection(frozenset([5, 6])) == frozenset([])
assert frozenset([1, 2, 3]).intersection([1, 2]) == frozenset([1, 2])
assert frozenset([1,2,3]) & frozenset([4,5]) == frozenset([])
assert frozenset([1,2,3]) & frozenset([1,2,3,4,5]) == frozenset([1,2,3])
assert_raises(TypeError, lambda: frozenset([1,2,3]) & [1,2,3,4,5])
assert frozenset([1, 2, 3]) & frozenset([4, 5]) == frozenset([])
assert frozenset([1, 2, 3]) & frozenset([1, 2, 3, 4, 5]) == frozenset([1, 2, 3])
assert_raises(TypeError, lambda: frozenset([1, 2, 3]) & [1, 2, 3, 4, 5])
assert frozenset([1,2,3]).difference(frozenset([1,2])) == frozenset([3])
assert frozenset([1,2,3]).difference(frozenset([5,6])) == frozenset([1,2,3])
assert frozenset([1,2,3]).difference([1,2]) == frozenset([3])
assert frozenset([1, 2, 3]).difference(frozenset([1, 2])) == frozenset([3])
assert frozenset([1, 2, 3]).difference(frozenset([5, 6])) == frozenset([1, 2, 3])
assert frozenset([1, 2, 3]).difference([1, 2]) == frozenset([3])
assert frozenset([1,2,3]) - frozenset([4,5]) == frozenset([1,2,3])
assert frozenset([1,2,3]) - frozenset([1,2,3,4,5]) == frozenset([])
assert_raises(TypeError, lambda: frozenset([1,2,3]) - [1,2,3,4,5])
assert frozenset([1, 2, 3]) - frozenset([4, 5]) == frozenset([1, 2, 3])
assert frozenset([1, 2, 3]) - frozenset([1, 2, 3, 4, 5]) == frozenset([])
assert_raises(TypeError, lambda: frozenset([1, 2, 3]) - [1, 2, 3, 4, 5])
assert frozenset([1,2]).__sub__(frozenset([2,3])) == frozenset([1])
assert frozenset([1,2]).__rsub__(frozenset([2,3])) == frozenset([3])
assert frozenset([1, 2]).__sub__(frozenset([2, 3])) == frozenset([1])
assert frozenset([1, 2]).__rsub__(frozenset([2, 3])) == frozenset([3])
assert frozenset([1,2,3]).symmetric_difference(frozenset([1,2])) == frozenset([3])
assert frozenset([1,2,3]).symmetric_difference(frozenset([5,6])) == frozenset([1,2,3,5,6])
assert frozenset([1,2,3]).symmetric_difference([1,2]) == frozenset([3])
assert frozenset([1, 2, 3]).symmetric_difference(frozenset([1, 2])) == frozenset([3])
assert frozenset([1, 2, 3]).symmetric_difference(frozenset([5, 6])) == frozenset(
[1, 2, 3, 5, 6]
)
assert frozenset([1, 2, 3]).symmetric_difference([1, 2]) == frozenset([3])
assert frozenset([1,2,3]) ^ frozenset([4,5]) == frozenset([1,2,3,4,5])
assert frozenset([1,2,3]) ^ frozenset([1,2,3,4,5]) == frozenset([4,5])
assert_raises(TypeError, lambda: frozenset([1,2,3]) ^ [1,2,3,4,5])
assert frozenset([1, 2, 3]) ^ frozenset([4, 5]) == frozenset([1, 2, 3, 4, 5])
assert frozenset([1, 2, 3]) ^ frozenset([1, 2, 3, 4, 5]) == frozenset([4, 5])
assert_raises(TypeError, lambda: frozenset([1, 2, 3]) ^ [1, 2, 3, 4, 5])
assert frozenset([1,2,3]).isdisjoint(frozenset([5,6])) == True
assert frozenset([1,2,3]).isdisjoint(frozenset([2,5,6])) == False
assert frozenset([1,2,3]).isdisjoint([5,6]) == True
assert frozenset([1, 2, 3]).isdisjoint(frozenset([5, 6])) == True
assert frozenset([1, 2, 3]).isdisjoint(frozenset([2, 5, 6])) == False
assert frozenset([1, 2, 3]).isdisjoint([5, 6]) == True
assert_raises(TypeError, frozenset, [[]])
a = frozenset([1,2,3])
a = frozenset([1, 2, 3])
b = set()
for e in a:
assert e == 1 or e == 2 or e == 3
b.add(e)
assert e == 1 or e == 2 or e == 3
b.add(e)
assert a == b
# set and frozen set
assert frozenset([1,2,3]).union(set([4,5])) == frozenset([1,2,3,4,5])
assert set([1,2,3]).union(frozenset([4,5])) == set([1,2,3,4,5])
assert frozenset([1, 2, 3]).union(set([4, 5])) == frozenset([1, 2, 3, 4, 5])
assert set([1, 2, 3]).union(frozenset([4, 5])) == set([1, 2, 3, 4, 5])
assert frozenset([1,2,3]) | set([4,5]) == frozenset([1,2,3,4,5])
assert set([1,2,3]) | frozenset([4,5]) == set([1,2,3,4,5])
assert frozenset([1, 2, 3]) | set([4, 5]) == frozenset([1, 2, 3, 4, 5])
assert set([1, 2, 3]) | frozenset([4, 5]) == set([1, 2, 3, 4, 5])
assert frozenset([1,2,3]).intersection(set([5,6])) == frozenset([])
assert set([1,2,3]).intersection(frozenset([5,6])) == set([])
assert frozenset([1, 2, 3]).intersection(set([5, 6])) == frozenset([])
assert set([1, 2, 3]).intersection(frozenset([5, 6])) == set([])
assert frozenset([1,2,3]) & set([1,2,3,4,5]) == frozenset([1,2,3])
assert set([1,2,3]) & frozenset([1,2,3,4,5]) == set([1,2,3])
assert frozenset([1, 2, 3]) & set([1, 2, 3, 4, 5]) == frozenset([1, 2, 3])
assert set([1, 2, 3]) & frozenset([1, 2, 3, 4, 5]) == set([1, 2, 3])
assert frozenset([1,2,3]).difference(set([5,6])) == frozenset([1,2,3])
assert set([1,2,3]).difference(frozenset([5,6])) == set([1,2,3])
assert frozenset([1, 2, 3]).difference(set([5, 6])) == frozenset([1, 2, 3])
assert set([1, 2, 3]).difference(frozenset([5, 6])) == set([1, 2, 3])
assert frozenset([1,2,3]) - set([4,5]) == frozenset([1,2,3])
assert set([1,2,3]) - frozenset([4,5]) == frozenset([1,2,3])
assert frozenset([1, 2, 3]) - set([4, 5]) == frozenset([1, 2, 3])
assert set([1, 2, 3]) - frozenset([4, 5]) == frozenset([1, 2, 3])
assert frozenset([1,2]).__sub__(set([2,3])) == frozenset([1])
assert frozenset([1,2]).__rsub__(set([2,3])) == set([3])
assert set([1,2]).__sub__(frozenset([2,3])) == set([1])
assert set([1,2]).__rsub__(frozenset([2,3])) == frozenset([3])
assert frozenset([1, 2]).__sub__(set([2, 3])) == frozenset([1])
assert frozenset([1, 2]).__rsub__(set([2, 3])) == set([3])
assert set([1, 2]).__sub__(frozenset([2, 3])) == set([1])
assert set([1, 2]).__rsub__(frozenset([2, 3])) == frozenset([3])
assert frozenset([1,2,3]).symmetric_difference(set([1,2])) == frozenset([3])
assert set([1,2,3]).symmetric_difference(frozenset([1,2])) == set([3])
assert frozenset([1, 2, 3]).symmetric_difference(set([1, 2])) == frozenset([3])
assert set([1, 2, 3]).symmetric_difference(frozenset([1, 2])) == set([3])
assert frozenset([1, 2, 3]) ^ set([4, 5]) == frozenset([1, 2, 3, 4, 5])
assert set([1, 2, 3]) ^ frozenset([4, 5]) == set([1, 2, 3, 4, 5])
assert frozenset([1,2,3]) ^ set([4,5]) == frozenset([1,2,3,4,5])
assert set([1,2,3]) ^ frozenset([4,5]) == set([1,2,3,4,5])
class A:
def __hash__(self):
return 1
class B:
def __hash__(self):
return 1
s = {1, A(), B()}
assert len(s) == 3
s = {True}
s.add(1.0)
assert str(s) == '{True}'
assert str(s) == "{True}"
class EqObject:
def __init__(self, eq):
self.eq = eq
def __eq__(self, other):
return self.eq
def __hash__(self):
return bool(self.eq)
assert 'x' == (EqObject('x') == EqObject('x'))
s = {EqObject('x')}
assert EqObject('x') in s
assert '[]' == (EqObject('[]') == EqObject('[]'))
assert "x" == (EqObject("x") == EqObject("x"))
s = {EqObject("x")}
assert EqObject("x") in s
assert "[]" == (EqObject("[]") == EqObject("[]"))
s = {EqObject([])}
assert EqObject([]) not in s
x = object()
@@ -372,8 +404,8 @@ assert not frozenset([1, 2]).__ne__(frozenset([2, 1]))
assert frozenset().__ne__(1) == NotImplemented
empty_set = set()
non_empty_set = set([1,2,3])
set_from_literal = {1,2,3}
non_empty_set = set([1, 2, 3])
set_from_literal = {1, 2, 3}
assert 1 in non_empty_set
assert 4 not in non_empty_set
@@ -382,8 +414,8 @@ assert 1 in set_from_literal
assert 4 not in set_from_literal
# TODO: Assert that empty aruguments raises exception.
non_empty_set.add('a')
assert 'a' in non_empty_set
non_empty_set.add("a")
assert "a" in non_empty_set
# TODO: Assert that empty arguments, or item not in set raises exception.
non_empty_set.remove(1)
@@ -394,8 +426,10 @@ assert 1 not in non_empty_set
assert repr(frozenset()) == "frozenset()"
assert repr(frozenset([1, 2, 3])) == "frozenset({1, 2, 3})"
class FS(frozenset):
pass
assert repr(FS()) == "FS()"
assert repr(FS([1, 2, 3])) == "FS({1, 2, 3})"
extra_tests/snippets/builtin_slice.py
+31 -35
View File
@@ -10,16 +10,16 @@ assert a.start == 0
assert a.stop == 10
assert a.step == 1
assert slice(10).__repr__() == 'slice(None, 10, None)'
assert slice(None).__repr__() == 'slice(None, None, None)'
assert slice(0, 10, 13).__repr__() == 'slice(0, 10, 13)'
assert slice('0', 1.1, 2+3j).__repr__() == "slice('0', 1.1, (2+3j))"
assert slice(10).__repr__() == "slice(None, 10, None)"
assert slice(None).__repr__() == "slice(None, None, None)"
assert slice(0, 10, 13).__repr__() == "slice(0, 10, 13)"
assert slice("0", 1.1, 2 + 3j).__repr__() == "slice('0', 1.1, (2+3j))"
assert slice(10) == slice(10)
assert slice(-1) != slice(1)
assert slice(0, 10, 3) != slice(0, 11, 3)
assert slice(0, None, 3) != slice(0, 'a', 3)
assert slice(0, 'a', 3) == slice(0, 'a', 3)
assert slice(0, None, 3) != slice(0, "a", 3)
assert slice(0, "a", 3) == slice(0, "a", 3)
assert slice(0, 0, 0).__eq__(slice(0, 0, 0))
assert not slice(0, 0, 1).__eq__(slice(0, 0, 0))
@@ -65,29 +65,29 @@ assert slice(0, 0, 0) <= slice(0, 0, 0)
assert not slice(0, 0, 0) > slice(0, 0, 0)
assert not slice(0, 0, 0) < slice(0, 0, 0)
assert not slice(0, float('nan'), float('nan')) <= slice(0, float('nan'), 1)
assert not slice(0, float('nan'), float('nan')) <= slice(0, float('nan'), float('nan'))
assert not slice(0, float('nan'), float('nan')) >= slice(0, float('nan'), float('nan'))
assert not slice(0, float('nan'), float('nan')) < slice(0, float('nan'), float('nan'))
assert not slice(0, float('nan'), float('nan')) > slice(0, float('nan'), float('nan'))
assert not slice(0, float("nan"), float("nan")) <= slice(0, float("nan"), 1)
assert not slice(0, float("nan"), float("nan")) <= slice(0, float("nan"), float("nan"))
assert not slice(0, float("nan"), float("nan")) >= slice(0, float("nan"), float("nan"))
assert not slice(0, float("nan"), float("nan")) < slice(0, float("nan"), float("nan"))
assert not slice(0, float("nan"), float("nan")) > slice(0, float("nan"), float("nan"))
assert slice(0, float('inf'), float('inf')) >= slice(0, float('inf'), 1)
assert slice(0, float('inf'), float('inf')) <= slice(0, float('inf'), float('inf'))
assert slice(0, float('inf'), float('inf')) >= slice(0, float('inf'), float('inf'))
assert not slice(0, float('inf'), float('inf')) < slice(0, float('inf'), float('inf'))
assert not slice(0, float('inf'), float('inf')) > slice(0, float('inf'), float('inf'))
assert slice(0, float("inf"), float("inf")) >= slice(0, float("inf"), 1)
assert slice(0, float("inf"), float("inf")) <= slice(0, float("inf"), float("inf"))
assert slice(0, float("inf"), float("inf")) >= slice(0, float("inf"), float("inf"))
assert not slice(0, float("inf"), float("inf")) < slice(0, float("inf"), float("inf"))
assert not slice(0, float("inf"), float("inf")) > slice(0, float("inf"), float("inf"))
assert_raises(TypeError, lambda: slice(0) < 3)
assert_raises(TypeError, lambda: slice(0) > 3)
assert_raises(TypeError, lambda: slice(0) <= 3)
assert_raises(TypeError, lambda: slice(0) >= 3)
assert slice(None ).indices(10) == (0, 10, 1)
assert slice(None, None, 2).indices(10) == (0, 10, 2)
assert slice(1, None, 2).indices(10) == (1, 10, 2)
assert slice(None, None, -1).indices(10) == (9, -1, -1)
assert slice(None, None, -2).indices(10) == (9, -1, -2)
assert slice(3, None, -2).indices(10) == (3, -1, -2)
assert slice(None).indices(10) == (0, 10, 1)
assert slice(None, None, 2).indices(10) == (0, 10, 2)
assert slice(1, None, 2).indices(10) == (1, 10, 2)
assert slice(None, None, -1).indices(10) == (9, -1, -1)
assert slice(None, None, -2).indices(10) == (9, -1, -2)
assert slice(3, None, -2).indices(10) == (3, -1, -2)
# issue 3004 tests
assert slice(None, -9).indices(10) == (0, 1, 1)
@@ -103,21 +103,17 @@ assert slice(None, 8, -1).indices(10) == (9, 8, -1)
assert slice(None, 9, -1).indices(10) == (9, 9, -1)
assert slice(None, 10, -1).indices(10) == (9, 9, -1)
assert \
slice(-100, 100).indices(10) == \
slice(None ).indices(10)
assert slice(-100, 100).indices(10) == slice(None).indices(10)
assert \
slice(100, -100, -1).indices(10) == \
slice(None, None, -1).indices(10)
assert slice(100, -100, -1).indices(10) == slice(None, None, -1).indices(10)
assert slice(-100, 100, 2).indices(10) == (0, 10, 2)
assert slice(-100, 100, 2).indices(10) == (0, 10, 2)
try:
slice(None, None, 0)
assert "zero step" == "throws an exception"
slice(None, None, 0)
assert "zero step" == "throws an exception"
except:
pass
pass
a = []
b = [1, 2]
@@ -167,8 +163,8 @@ class CustomIndex:
return self.x
assert c[CustomIndex(1):CustomIndex(3)] == [1, 2]
assert d[CustomIndex(1):CustomIndex(3)] == "23"
assert c[CustomIndex(1) : CustomIndex(3)] == [1, 2]
assert d[CustomIndex(1) : CustomIndex(3)] == "23"
def test_all_slices():
@@ -176,7 +172,7 @@ def test_all_slices():
test all possible slices except big number
"""
mod = __import__('cpython_generated_slices')
mod = __import__("cpython_generated_slices")
ll = mod.LL
start = mod.START
extra_tests/snippets/builtin_str.py
+522 -441
View File
File diff suppressed because it is too large. Load diff
extra_tests/snippets/builtin_str_encode.py
+2
View File
@@ -10,11 +10,13 @@ else:
assert_raises(UnicodeEncodeError, "¿como estás?".encode, "ascii")
def round_trip(s, encoding="utf-8"):
encoded = s.encode(encoding)
decoded = encoded.decode(encoding)
assert s == decoded
round_trip("👺♦ 𝐚Şđƒ ☆☝")
round_trip("☢🐣 ᖇ𝓤𝕊тⓟ𝕐𝕥卄σ𝔫 ♬👣")
round_trip("💀👌 ק𝔂tℍⓞ𝓷 ３ 🔥👤")
extra_tests/snippets/builtin_str_subclass.py
+2
View File
@@ -3,6 +3,7 @@ from testutils import assert_raises
x = "An interesting piece of text"
assert x is str(x)
class Stringy(str):
def __new__(cls, value=""):
return str.__new__(cls, value)
@@ -10,6 +11,7 @@ class Stringy(str):
def __init__(self, value):
self.x = "substr"
y = Stringy(1)
assert type(y) is Stringy, "Type of Stringy should be stringy"
assert type(str(y)) is str, "Str of a str-subtype should be a str."
extra_tests/snippets/builtin_str_unicode.py
+15 -15
View File
@@ -1,29 +1,29 @@
# Test the unicode support! 👋
ᚴ=2
ᚴ = 2
assert ᚴ*8 == 16
assert ᚴ * 8 == 16
ᚴ="👋"
ᚴ = "👋"
c = ᚴ*3
c = ᚴ * 3
assert c == '👋👋👋'
assert c == "👋👋👋"
import unicodedata
assert unicodedata.category('a') == 'Ll'
assert unicodedata.category('A') == 'Lu'
assert unicodedata.name('a') == 'LATIN SMALL LETTER A'
assert unicodedata.lookup('LATIN SMALL LETTER A') == 'a'
assert unicodedata.bidirectional('a') == 'L'
assert unicodedata.east_asian_width('\u231a') == 'W'
assert unicodedata.normalize('NFC', 'bla') == 'bla'
assert unicodedata.category("a") == "Ll"
assert unicodedata.category("A") == "Lu"
assert unicodedata.name("a") == "LATIN SMALL LETTER A"
assert unicodedata.lookup("LATIN SMALL LETTER A") == "a"
assert unicodedata.bidirectional("a") == "L"
assert unicodedata.east_asian_width("\u231a") == "W"
assert unicodedata.normalize("NFC", "bla") == "bla"
# testing unicodedata.ucd_3_2_0 for idna
assert "abcСĤ".encode("idna") == b'xn--abc-7sa390b'
assert "abc䄣IJ".encode("idna") == b'xn--abcij-zb5f'
assert "abcСĤ".encode("idna") == b"xn--abc-7sa390b"
assert "abc䄣IJ".encode("idna") == b"xn--abcij-zb5f"
# from CPython tests
assert "python.org".encode("idna") == b"python.org"
extra_tests/snippets/builtin_str_unicode_slice.py
+19 -17
View File
@@ -1,13 +1,14 @@
def test_slice_bounds(s):
# End out of range
assert s[0:100] == s
assert s[0:-100] == ''
assert s[0:-100] == ""
# Start out of range
assert s[100:1] == ''
assert s[100:1] == ""
# Out of range both sides
# This is the behaviour in cpython
# assert s[-100:100] == s
def expect_index_error(s, index):
try:
s[index]
@@ -16,6 +17,7 @@ def expect_index_error(s, index):
else:
assert False
unicode_str = "∀∂"
assert unicode_str[0] == "∀"
assert unicode_str[1] == "∂"
@@ -35,25 +37,25 @@ assert ascii_str[-1] == "d"
hebrew_text = "בְּרֵאשִׁית, בָּרָא אֱלֹהִים, אֵת הַשָּׁמַיִם, וְאֵת הָאָרֶץ"
assert len(hebrew_text) == 60
assert len(hebrew_text[:]) == 60
assert hebrew_text[0] == 'ב'
assert hebrew_text[1] == 'ְ'
assert hebrew_text[2] == 'ּ'
assert hebrew_text[3] == 'ר'
assert hebrew_text[4] == 'ֵ'
assert hebrew_text[5] == 'א'
assert hebrew_text[6] == 'ש'
assert hebrew_text[5:10] == 'אשִׁי'
assert hebrew_text[0] == "ב"
assert hebrew_text[1] == "ְ"
assert hebrew_text[2] == "ּ"
assert hebrew_text[3] == "ר"
assert hebrew_text[4] == "ֵ"
assert hebrew_text[5] == "א"
assert hebrew_text[6] == "ש"
assert hebrew_text[5:10] == "אשִׁי"
assert len(hebrew_text[5:10]) == 5
assert hebrew_text[-20:50] == 'מַיִם, וְא'
assert hebrew_text[-20:50] == "מַיִם, וְא"
assert len(hebrew_text[-20:50]) == 10
assert hebrew_text[:-30:1] == 'בְּרֵאשִׁית, בָּרָא אֱלֹהִים, '
assert hebrew_text[:-30:1] == "בְּרֵאשִׁית, בָּרָא אֱלֹהִים, "
assert len(hebrew_text[:-30:1]) == 30
assert hebrew_text[10:-30] == 'ת, בָּרָא אֱלֹהִים, '
assert hebrew_text[10:-30] == "ת, בָּרָא אֱלֹהִים, "
assert len(hebrew_text[10:-30]) == 20
assert hebrew_text[10:30:3] == 'תבר לִ,'
assert hebrew_text[10:30:3] == "תבר לִ,"
assert len(hebrew_text[10:30:3]) == 7
assert hebrew_text[10:30:-3] == ''
assert hebrew_text[30:10:-3] == 'אםהֱאּ '
assert hebrew_text[10:30:-3] == ""
assert hebrew_text[30:10:-3] == "אםהֱאּ "
assert len(hebrew_text[30:10:-3]) == 7
assert hebrew_text[30:10:-1] == 'א ,םיִהֹלֱא אָרָּב ,'
assert hebrew_text[30:10:-1] == "א ,םיִהֹלֱא אָרָּב ,"
assert len(hebrew_text[30:10:-1]) == 20
extra_tests/snippets/builtin_tuple.py
+16 -14
View File
@@ -1,8 +1,8 @@
from testutils import assert_raises
assert (1,2) == (1,2)
assert (1, 2) == (1, 2)
x = (1,2)
x = (1, 2)
assert x[0] == 1
y = (1,)
@@ -19,7 +19,7 @@ assert y < x, "tuple __lt__ failed"
assert x > y, "tuple __gt__ failed"
b = (1,2,3)
b = (1, 2, 3)
assert b.index(2) == 1
recursive_list = []
@@ -30,15 +30,17 @@ assert repr(recursive) == "([(...)],)"
assert (None, "", 1).index(1) == 2
assert 1 in (None, "", 1)
class Foo(object):
def __eq__(self, x):
return False
foo = Foo()
assert (foo,) == (foo,)
a = (1, 2, 3)
a += 1,
a += (1,)
assert a == (1, 2, 3, 1)
b = (55, *a)
@@ -80,14 +82,14 @@ assert (0, 0) <= (0, 0)
assert not (0, 0) > (0, 0)
assert not (0, 0) < (0, 0)
assert not (float('nan'), float('nan')) <= (float('nan'), 1)
assert not (float('nan'), float('nan')) <= (float('nan'), float('nan'))
assert not (float('nan'), float('nan')) >= (float('nan'), float('nan'))
assert not (float('nan'), float('nan')) < (float('nan'), float('nan'))
assert not (float('nan'), float('nan')) > (float('nan'), float('nan'))
assert not (float("nan"), float("nan")) <= (float("nan"), 1)
assert not (float("nan"), float("nan")) <= (float("nan"), float("nan"))
assert not (float("nan"), float("nan")) >= (float("nan"), float("nan"))
assert not (float("nan"), float("nan")) < (float("nan"), float("nan"))
assert not (float("nan"), float("nan")) > (float("nan"), float("nan"))
assert (float('inf'), float('inf')) >= (float('inf'), 1)
assert (float('inf'), float('inf')) <= (float('inf'), float('inf'))
assert (float('inf'), float('inf')) >= (float('inf'), float('inf'))
assert not (float('inf'), float('inf')) < (float('inf'), float('inf'))
assert not (float('inf'), float('inf')) > (float('inf'), float('inf'))
assert (float("inf"), float("inf")) >= (float("inf"), 1)
assert (float("inf"), float("inf")) <= (float("inf"), float("inf"))
assert (float("inf"), float("inf")) >= (float("inf"), float("inf"))
assert not (float("inf"), float("inf")) < (float("inf"), float("inf"))
assert not (float("inf"), float("inf")) > (float("inf"), float("inf"))
extra_tests/snippets/builtin_type.py
+216 -186
View File
@@ -13,9 +13,9 @@ print(1.1)
print("abc")
# print(u"abc")
# Structural below
print((1, 2)) # Tuple can be any length, but fixed after declared
x = (1,2)
print(x[0]) # Tuple can be any length, but fixed after declared
print((1, 2)) # Tuple can be any length, but fixed after declared
x = (1, 2)
print(x[0]) # Tuple can be any length, but fixed after declared
print([1, 2, 3])
# print({"first":1,"second":2})
@@ -52,25 +52,25 @@ assert int() == 0
a = complex(2, 4)
assert type(a) is complex
assert type(a + a) is complex
assert repr(a) == '(2+4j)'
assert repr(a) == "(2+4j)"
a = 10j
assert repr(a) == '10j'
assert repr(a) == "10j"
a = 1
assert a.conjugate() == a
a = 12345
b = a*a*a*a*a*a*a*a
b = a * a * a * a * a * a * a * a
assert b.bit_length() == 109
assert type.__module__ == 'builtins'
assert type.__qualname__ == 'type'
assert type.__name__ == 'type'
assert type.__module__ == "builtins"
assert type.__qualname__ == "type"
assert type.__name__ == "type"
assert isinstance(type.__doc__, str)
assert object.__qualname__ == 'object'
assert int.__qualname__ == 'int'
assert object.__qualname__ == "object"
assert int.__qualname__ == "int"
class A(type):
@@ -78,8 +78,8 @@ class A(type):
class B(type):
__module__ = 'b'
__qualname__ = 'BB'
__module__ = "b"
__qualname__ = "BB"
class C:
@@ -87,23 +87,23 @@ class C:
class D:
__module__ = 'd'
__qualname__ = 'DD'
__module__ = "d"
__qualname__ = "DD"
assert A.__module__ == '__main__'
assert A.__qualname__ == 'A'
assert B.__module__ == 'b'
assert B.__qualname__ == 'BB'
assert C.__module__ == '__main__'
assert C.__qualname__ == 'C'
assert D.__module__ == 'd'
assert D.__qualname__ == 'DD'
assert A.__module__ == "__main__"
assert A.__qualname__ == "A"
assert B.__module__ == "b"
assert B.__qualname__ == "BB"
assert C.__module__ == "__main__"
assert C.__qualname__ == "C"
assert D.__module__ == "d"
assert D.__qualname__ == "DD"
A.__qualname__ = 'AA'
B.__qualname__ = 'b'
assert A.__qualname__ == 'AA'
assert B.__qualname__ == 'b'
A.__qualname__ = "AA"
B.__qualname__ = "b"
assert A.__qualname__ == "AA"
assert B.__qualname__ == "b"
with assert_raises(TypeError):
del D.__qualname__
with assert_raises(TypeError):
@@ -114,7 +114,8 @@ with assert_raises(TypeError):
from testutils import assert_raises
import platform
if platform.python_implementation() == 'RustPython':
if platform.python_implementation() == "RustPython":
gc = None
else:
import gc
@@ -123,13 +124,13 @@ assert type(type) is type
assert type(object) is type
assert type(object()) is object
new_type = type('New', (object,), {})
new_type = type("New", (object,), {})
assert type(new_type) is type
assert type(new_type()) is new_type
metaclass = type('MCl', (type,), {})
cls = metaclass('Cls', (object,), {})
metaclass = type("MCl", (type,), {})
cls = metaclass("Cls", (object,), {})
inst = cls()
assert type(inst) is cls
@@ -154,10 +155,22 @@ assert isinstance(type, (int, object))
assert not issubclass(type, (int, float))
assert issubclass(type, (int, type))
class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
class A:
pass
class B(A):
pass
class C(A):
pass
class D(B, C):
pass
assert A.__subclasses__() == [B, C]
assert B.__subclasses__() == [D]
@@ -174,7 +187,7 @@ del D
if gc:
# gc sweep is needed here for CPython...
gc.collect()
# ...while RustPython doesn't have `gc` yet.
# ...while RustPython doesn't have `gc` yet.
if gc:
# D.__new__ is a method bound to the D type, so just deleting D
@@ -185,43 +198,53 @@ if gc:
assert type in object.__subclasses__()
assert cls.__name__ == 'Cls'
assert cls.__name__ == "Cls"
# mro
assert int.mro() == [int, object]
assert bool.mro() == [bool, int, object]
assert object.mro() == [object]
class A:
pass
class B(A):
pass
assert A.mro() == [A, object]
assert B.mro() == [B, A, object]
class AA:
pass
class BB(AA):
pass
class C(B, BB):
pass
assert C.mro() == [C, B, A, BB, AA, object]
assert type(Exception.args).__name__ == 'getset_descriptor'
assert type(Exception.args).__name__ == "getset_descriptor"
assert type(None).__bool__(None) is False
class A:
pass
class B:
pass
a = A()
a.__class__ = B
assert isinstance(a, B)
@@ -234,30 +257,33 @@ with assert_raises(TypeError):
# Regression to
# https://github.com/RustPython/RustPython/issues/2310
import builtins
assert builtins.iter.__class__.__module__ == 'builtins'
assert builtins.iter.__class__.__qualname__ == 'builtin_function_or_method'
assert iter.__class__.__module__ == 'builtins'
assert iter.__class__.__qualname__ == 'builtin_function_or_method'
assert type(iter).__module__ == 'builtins'
assert type(iter).__qualname__ == 'builtin_function_or_method'
assert builtins.iter.__class__.__module__ == "builtins"
assert builtins.iter.__class__.__qualname__ == "builtin_function_or_method"
assert iter.__class__.__module__ == "builtins"
assert iter.__class__.__qualname__ == "builtin_function_or_method"
assert type(iter).__module__ == "builtins"
assert type(iter).__qualname__ == "builtin_function_or_method"
# Regression to
# https://github.com/RustPython/RustPython/issues/2767
# Marked as `#[pymethod]`:
assert str.replace.__qualname__ == 'str.replace'
assert str().replace.__qualname__ == 'str.replace'
assert int.to_bytes.__qualname__ == 'int.to_bytes'
assert int().to_bytes.__qualname__ == 'int.to_bytes'
assert str.replace.__qualname__ == "str.replace"
assert str().replace.__qualname__ == "str.replace"
assert int.to_bytes.__qualname__ == "int.to_bytes"
assert int().to_bytes.__qualname__ == "int.to_bytes"
# Marked as `#[pyclassmethod]`:
assert dict.fromkeys.__qualname__ == 'dict.fromkeys'
assert object.__init_subclass__.__qualname__ == 'object.__init_subclass__'
assert dict.fromkeys.__qualname__ == "dict.fromkeys"
assert object.__init_subclass__.__qualname__ == "object.__init_subclass__"
# Dynamic with `#[extend_class]`:
assert bytearray.maketrans.__qualname__ == 'bytearray.maketrans', bytearray.maketrans.__qualname__
assert bytearray.maketrans.__qualname__ == "bytearray.maketrans", (
bytearray.maketrans.__qualname__
)
# Third-party:
@@ -285,47 +311,48 @@ class MyTypeWithMethod:
def s():
pass
assert MyTypeWithMethod.method.__name__ == 'method'
assert MyTypeWithMethod().method.__name__ == 'method'
assert MyTypeWithMethod.clsmethod.__name__ == 'clsmethod'
assert MyTypeWithMethod().clsmethod.__name__ == 'clsmethod'
assert MyTypeWithMethod.stmethod.__name__ == 'stmethod'
assert MyTypeWithMethod().stmethod.__name__ == 'stmethod'
assert MyTypeWithMethod.method.__qualname__ == 'MyTypeWithMethod.method'
assert MyTypeWithMethod().method.__qualname__ == 'MyTypeWithMethod.method'
assert MyTypeWithMethod.clsmethod.__qualname__ == 'MyTypeWithMethod.clsmethod'
assert MyTypeWithMethod().clsmethod.__qualname__ == 'MyTypeWithMethod.clsmethod'
assert MyTypeWithMethod.stmethod.__qualname__ == 'MyTypeWithMethod.stmethod'
assert MyTypeWithMethod().stmethod.__qualname__ == 'MyTypeWithMethod.stmethod'
assert MyTypeWithMethod.method.__name__ == "method"
assert MyTypeWithMethod().method.__name__ == "method"
assert MyTypeWithMethod.clsmethod.__name__ == "clsmethod"
assert MyTypeWithMethod().clsmethod.__name__ == "clsmethod"
assert MyTypeWithMethod.stmethod.__name__ == "stmethod"
assert MyTypeWithMethod().stmethod.__name__ == "stmethod"
assert MyTypeWithMethod.N.m.__name__ == 'm'
assert MyTypeWithMethod().N.m.__name__ == 'm'
assert MyTypeWithMethod.N.c.__name__ == 'c'
assert MyTypeWithMethod().N.c.__name__ == 'c'
assert MyTypeWithMethod.N.s.__name__ == 's'
assert MyTypeWithMethod().N.s.__name__ == 's'
assert MyTypeWithMethod.method.__qualname__ == "MyTypeWithMethod.method"
assert MyTypeWithMethod().method.__qualname__ == "MyTypeWithMethod.method"
assert MyTypeWithMethod.clsmethod.__qualname__ == "MyTypeWithMethod.clsmethod"
assert MyTypeWithMethod().clsmethod.__qualname__ == "MyTypeWithMethod.clsmethod"
assert MyTypeWithMethod.stmethod.__qualname__ == "MyTypeWithMethod.stmethod"
assert MyTypeWithMethod().stmethod.__qualname__ == "MyTypeWithMethod.stmethod"
assert MyTypeWithMethod.N.m.__qualname__ == 'MyTypeWithMethod.N.m'
assert MyTypeWithMethod().N.m.__qualname__ == 'MyTypeWithMethod.N.m'
assert MyTypeWithMethod.N.c.__qualname__ == 'MyTypeWithMethod.N.c'
assert MyTypeWithMethod().N.c.__qualname__ == 'MyTypeWithMethod.N.c'
assert MyTypeWithMethod.N.s.__qualname__ == 'MyTypeWithMethod.N.s'
assert MyTypeWithMethod().N.s.__qualname__ == 'MyTypeWithMethod.N.s'
assert MyTypeWithMethod.N.m.__name__ == "m"
assert MyTypeWithMethod().N.m.__name__ == "m"
assert MyTypeWithMethod.N.c.__name__ == "c"
assert MyTypeWithMethod().N.c.__name__ == "c"
assert MyTypeWithMethod.N.s.__name__ == "s"
assert MyTypeWithMethod().N.s.__name__ == "s"
assert MyTypeWithMethod.N().m.__name__ == 'm'
assert MyTypeWithMethod().N().m.__name__ == 'm'
assert MyTypeWithMethod.N().c.__name__ == 'c'
assert MyTypeWithMethod().N().c.__name__ == 'c'
assert MyTypeWithMethod.N().s.__name__ == 's'
assert MyTypeWithMethod().N.s.__name__ == 's'
assert MyTypeWithMethod.N.m.__qualname__ == "MyTypeWithMethod.N.m"
assert MyTypeWithMethod().N.m.__qualname__ == "MyTypeWithMethod.N.m"
assert MyTypeWithMethod.N.c.__qualname__ == "MyTypeWithMethod.N.c"
assert MyTypeWithMethod().N.c.__qualname__ == "MyTypeWithMethod.N.c"
assert MyTypeWithMethod.N.s.__qualname__ == "MyTypeWithMethod.N.s"
assert MyTypeWithMethod().N.s.__qualname__ == "MyTypeWithMethod.N.s"
assert MyTypeWithMethod.N().m.__qualname__ == 'MyTypeWithMethod.N.m'
assert MyTypeWithMethod().N().m.__qualname__ == 'MyTypeWithMethod.N.m'
assert MyTypeWithMethod.N().c.__qualname__ == 'MyTypeWithMethod.N.c'
assert MyTypeWithMethod().N().c.__qualname__ == 'MyTypeWithMethod.N.c'
assert MyTypeWithMethod.N().s.__qualname__ == 'MyTypeWithMethod.N.s'
assert MyTypeWithMethod().N().s.__qualname__ == 'MyTypeWithMethod.N.s'
assert MyTypeWithMethod.N().m.__name__ == "m"
assert MyTypeWithMethod().N().m.__name__ == "m"
assert MyTypeWithMethod.N().c.__name__ == "c"
assert MyTypeWithMethod().N().c.__name__ == "c"
assert MyTypeWithMethod.N().s.__name__ == "s"
assert MyTypeWithMethod().N.s.__name__ == "s"
assert MyTypeWithMethod.N().m.__qualname__ == "MyTypeWithMethod.N.m"
assert MyTypeWithMethod().N().m.__qualname__ == "MyTypeWithMethod.N.m"
assert MyTypeWithMethod.N().c.__qualname__ == "MyTypeWithMethod.N.c"
assert MyTypeWithMethod().N().c.__qualname__ == "MyTypeWithMethod.N.c"
assert MyTypeWithMethod.N().s.__qualname__ == "MyTypeWithMethod.N.s"
assert MyTypeWithMethod().N().s.__qualname__ == "MyTypeWithMethod.N.s"
# Regresesion to
@@ -339,26 +366,27 @@ assert repr(int.to_bytes) == "<method 'to_bytes' of 'int' objects>"
# Regression to
# https://github.com/RustPython/RustPython/issues/2788
assert iter.__qualname__ == iter.__name__ == 'iter'
assert max.__qualname__ == max.__name__ == 'max'
assert min.__qualname__ == min.__name__ == 'min'
assert iter.__qualname__ == iter.__name__ == "iter"
assert max.__qualname__ == max.__name__ == "max"
assert min.__qualname__ == min.__name__ == "min"
def custom_func():
pass
assert custom_func.__qualname__ == 'custom_func'
assert custom_func.__qualname__ == "custom_func"
# Regression to
# https://github.com/RustPython/RustPython/issues/2786
assert object.__new__.__name__ == '__new__'
assert object.__new__.__qualname__ == 'object.__new__'
assert object.__subclasshook__.__name__ == '__subclasshook__'
assert object.__subclasshook__.__qualname__ == 'object.__subclasshook__'
assert type.__new__.__name__ == '__new__'
assert type.__new__.__qualname__ == 'type.__new__'
assert object.__new__.__name__ == "__new__"
assert object.__new__.__qualname__ == "object.__new__"
assert object.__subclasshook__.__name__ == "__subclasshook__"
assert object.__subclasshook__.__qualname__ == "object.__subclasshook__"
assert type.__new__.__name__ == "__new__"
assert type.__new__.__qualname__ == "type.__new__"
class AQ:
@@ -414,75 +442,76 @@ class BQ(AQ):
def three_st():
pass
assert AQ.one.__name__ == 'one'
assert AQ().one.__name__ == 'one'
assert AQ.one_cls.__name__ == 'one_cls'
assert AQ().one_cls.__name__ == 'one_cls'
assert AQ.one_st.__name__ == 'one_st'
assert AQ().one_st.__name__ == 'one_st'
assert AQ.one.__qualname__ == 'AQ.one'
assert AQ().one.__qualname__ == 'AQ.one'
assert AQ.one_cls.__qualname__ == 'AQ.one_cls'
assert AQ().one_cls.__qualname__ == 'AQ.one_cls'
assert AQ.one_st.__qualname__ == 'AQ.one_st'
assert AQ().one_st.__qualname__ == 'AQ.one_st'
assert AQ.one.__name__ == "one"
assert AQ().one.__name__ == "one"
assert AQ.one_cls.__name__ == "one_cls"
assert AQ().one_cls.__name__ == "one_cls"
assert AQ.one_st.__name__ == "one_st"
assert AQ().one_st.__name__ == "one_st"
assert AQ.two.__name__ == 'two'
assert AQ().two.__name__ == 'two'
assert AQ.two_cls.__name__ == 'two_cls'
assert AQ().two_cls.__name__ == 'two_cls'
assert AQ.two_st.__name__ == 'two_st'
assert AQ().two_st.__name__ == 'two_st'
assert AQ.one.__qualname__ == "AQ.one"
assert AQ().one.__qualname__ == "AQ.one"
assert AQ.one_cls.__qualname__ == "AQ.one_cls"
assert AQ().one_cls.__qualname__ == "AQ.one_cls"
assert AQ.one_st.__qualname__ == "AQ.one_st"
assert AQ().one_st.__qualname__ == "AQ.one_st"
assert AQ.two.__qualname__ == 'AQ.two'
assert AQ().two.__qualname__ == 'AQ.two'
assert AQ.two_cls.__qualname__ == 'AQ.two_cls'
assert AQ().two_cls.__qualname__ == 'AQ.two_cls'
assert AQ.two_st.__qualname__ == 'AQ.two_st'
assert AQ().two_st.__qualname__ == 'AQ.two_st'
assert AQ.two.__name__ == "two"
assert AQ().two.__name__ == "two"
assert AQ.two_cls.__name__ == "two_cls"
assert AQ().two_cls.__name__ == "two_cls"
assert AQ.two_st.__name__ == "two_st"
assert AQ().two_st.__name__ == "two_st"
assert BQ.one.__name__ == 'one'
assert BQ().one.__name__ == 'one'
assert BQ.one_cls.__name__ == 'one_cls'
assert BQ().one_cls.__name__ == 'one_cls'
assert BQ.one_st.__name__ == 'one_st'
assert BQ().one_st.__name__ == 'one_st'
assert AQ.two.__qualname__ == "AQ.two"
assert AQ().two.__qualname__ == "AQ.two"
assert AQ.two_cls.__qualname__ == "AQ.two_cls"
assert AQ().two_cls.__qualname__ == "AQ.two_cls"
assert AQ.two_st.__qualname__ == "AQ.two_st"
assert AQ().two_st.__qualname__ == "AQ.two_st"
assert BQ.one.__qualname__ == 'BQ.one'
assert BQ().one.__qualname__ == 'BQ.one'
assert BQ.one_cls.__qualname__ == 'BQ.one_cls'
assert BQ().one_cls.__qualname__ == 'BQ.one_cls'
assert BQ.one_st.__qualname__ == 'BQ.one_st'
assert BQ().one_st.__qualname__ == 'BQ.one_st'
assert BQ.one.__name__ == "one"
assert BQ().one.__name__ == "one"
assert BQ.one_cls.__name__ == "one_cls"
assert BQ().one_cls.__name__ == "one_cls"
assert BQ.one_st.__name__ == "one_st"
assert BQ().one_st.__name__ == "one_st"
assert BQ.two.__name__ == 'two'
assert BQ().two.__name__ == 'two'
assert BQ.two_cls.__name__ == 'two_cls'
assert BQ().two_cls.__name__ == 'two_cls'
assert BQ.two_st.__name__ == 'two_st'
assert BQ().two_st.__name__ == 'two_st'
assert BQ.one.__qualname__ == "BQ.one"
assert BQ().one.__qualname__ == "BQ.one"
assert BQ.one_cls.__qualname__ == "BQ.one_cls"
assert BQ().one_cls.__qualname__ == "BQ.one_cls"
assert BQ.one_st.__qualname__ == "BQ.one_st"
assert BQ().one_st.__qualname__ == "BQ.one_st"
assert BQ.two.__qualname__ == 'AQ.two'
assert BQ().two.__qualname__ == 'AQ.two'
assert BQ.two_cls.__qualname__ == 'AQ.two_cls'
assert BQ().two_cls.__qualname__ == 'AQ.two_cls'
assert BQ.two_st.__qualname__ == 'AQ.two_st'
assert BQ().two_st.__qualname__ == 'AQ.two_st'
assert BQ.two.__name__ == "two"
assert BQ().two.__name__ == "two"
assert BQ.two_cls.__name__ == "two_cls"
assert BQ().two_cls.__name__ == "two_cls"
assert BQ.two_st.__name__ == "two_st"
assert BQ().two_st.__name__ == "two_st"
assert BQ.three.__name__ == 'three'
assert BQ().three.__name__ == 'three'
assert BQ.three_cls.__name__ == 'three_cls'
assert BQ().three_cls.__name__ == 'three_cls'
assert BQ.three_st.__name__ == 'three_st'
assert BQ().three_st.__name__ == 'three_st'
assert BQ.two.__qualname__ == "AQ.two"
assert BQ().two.__qualname__ == "AQ.two"
assert BQ.two_cls.__qualname__ == "AQ.two_cls"
assert BQ().two_cls.__qualname__ == "AQ.two_cls"
assert BQ.two_st.__qualname__ == "AQ.two_st"
assert BQ().two_st.__qualname__ == "AQ.two_st"
assert BQ.three.__qualname__ == 'BQ.three'
assert BQ().three.__qualname__ == 'BQ.three'
assert BQ.three_cls.__qualname__ == 'BQ.three_cls'
assert BQ().three_cls.__qualname__ == 'BQ.three_cls'
assert BQ.three_st.__qualname__ == 'BQ.three_st'
assert BQ().three_st.__qualname__ == 'BQ.three_st'
assert BQ.three.__name__ == "three"
assert BQ().three.__name__ == "three"
assert BQ.three_cls.__name__ == "three_cls"
assert BQ().three_cls.__name__ == "three_cls"
assert BQ.three_st.__name__ == "three_st"
assert BQ().three_st.__name__ == "three_st"
assert BQ.three.__qualname__ == "BQ.three"
assert BQ().three.__qualname__ == "BQ.three"
assert BQ.three_cls.__qualname__ == "BQ.three_cls"
assert BQ().three_cls.__qualname__ == "BQ.three_cls"
assert BQ.three_st.__qualname__ == "BQ.three_st"
assert BQ().three_st.__qualname__ == "BQ.three_st"
class ClassWithNew:
@@ -494,73 +523,74 @@ class ClassWithNew:
return super().__new__(cls, *args, **kwargs)
assert ClassWithNew.__new__.__qualname__ == 'ClassWithNew.__new__'
assert ClassWithNew().__new__.__qualname__ == 'ClassWithNew.__new__'
assert ClassWithNew.__new__.__name__ == '__new__'
assert ClassWithNew().__new__.__name__ == '__new__'
assert ClassWithNew.__new__.__qualname__ == "ClassWithNew.__new__"
assert ClassWithNew().__new__.__qualname__ == "ClassWithNew.__new__"
assert ClassWithNew.__new__.__name__ == "__new__"
assert ClassWithNew().__new__.__name__ == "__new__"
assert ClassWithNew.N.__new__.__qualname__ == 'ClassWithNew.N.__new__'
assert ClassWithNew().N.__new__.__qualname__ == 'ClassWithNew.N.__new__'
assert ClassWithNew.N.__new__.__name__ == '__new__'
assert ClassWithNew().N.__new__.__name__ == '__new__'
assert ClassWithNew.N().__new__.__qualname__ == 'ClassWithNew.N.__new__'
assert ClassWithNew().N().__new__.__qualname__ == 'ClassWithNew.N.__new__'
assert ClassWithNew.N().__new__.__name__ == '__new__'
assert ClassWithNew().N().__new__.__name__ == '__new__'
assert ClassWithNew.N.__new__.__qualname__ == "ClassWithNew.N.__new__"
assert ClassWithNew().N.__new__.__qualname__ == "ClassWithNew.N.__new__"
assert ClassWithNew.N.__new__.__name__ == "__new__"
assert ClassWithNew().N.__new__.__name__ == "__new__"
assert ClassWithNew.N().__new__.__qualname__ == "ClassWithNew.N.__new__"
assert ClassWithNew().N().__new__.__qualname__ == "ClassWithNew.N.__new__"
assert ClassWithNew.N().__new__.__name__ == "__new__"
assert ClassWithNew().N().__new__.__name__ == "__new__"
# Regression to:
# https://github.com/RustPython/RustPython/issues/2762
assert type.__prepare__() == {}
assert type.__prepare__('name') == {}
assert type.__prepare__('name', object) == {}
assert type.__prepare__('name', (bytes, str)) == {}
assert type.__prepare__("name") == {}
assert type.__prepare__("name", object) == {}
assert type.__prepare__("name", (bytes, str)) == {}
assert type.__prepare__(a=1, b=2) == {}
assert type.__prepare__('name', (object, int), kw=True) == {}
assert type.__prepare__("name", (object, int), kw=True) == {}
# Previously we needed `name` to be `str`:
assert type.__prepare__(1) == {}
assert int.__prepare__() == {}
assert int.__prepare__('name', (object, int), kw=True) == {}
assert int.__prepare__("name", (object, int), kw=True) == {}
# Regression to
# https://github.com/RustPython/RustPython/issues/2790
# `#[pyproperty]`
assert BaseException.args.__qualname__ == 'BaseException.args'
assert BaseException.args.__qualname__ == "BaseException.args"
# class extension without `#[pyproperty]` override
assert Exception.args.__qualname__ == 'BaseException.args'
assert Exception.args.__qualname__ == "BaseException.args"
# dynamic with `.new_readonly_getset`
assert SyntaxError.msg.__qualname__ == 'SyntaxError.msg'
assert SyntaxError.msg.__qualname__ == "SyntaxError.msg"
# Regression to
# https://github.com/RustPython/RustPython/issues/2794
assert type.__subclasshook__.__qualname__ == 'type.__subclasshook__'
assert object.__subclasshook__.__qualname__ == 'object.__subclasshook__'
assert type.__subclasshook__.__qualname__ == "type.__subclasshook__"
assert object.__subclasshook__.__qualname__ == "object.__subclasshook__"
# Regression to
# https://github.com/RustPython/RustPython/issues/2776
assert repr(BQ.one).startswith('<function BQ.one at 0x')
assert repr(BQ.one_st).startswith('<function BQ.one_st at 0x')
assert repr(BQ.one).startswith("<function BQ.one at 0x")
assert repr(BQ.one_st).startswith("<function BQ.one_st at 0x")
assert repr(BQ.two).startswith('<function AQ.two at 0x')
assert repr(BQ.two_st).startswith('<function AQ.two_st at 0x')
assert repr(BQ.two).startswith("<function AQ.two at 0x")
assert repr(BQ.two_st).startswith("<function AQ.two_st at 0x")
assert repr(BQ.three).startswith('<function BQ.three at 0x')
assert repr(BQ.three_st).startswith('<function BQ.three_st at 0x')
assert repr(BQ.three).startswith("<function BQ.three at 0x")
assert repr(BQ.three_st).startswith("<function BQ.three_st at 0x")
def my_repr_func():
pass
assert repr(my_repr_func).startswith('<function my_repr_func at 0x')
assert repr(my_repr_func).startswith("<function my_repr_func at 0x")
# https://github.com/RustPython/RustPython/issues/3100
extra_tests/snippets/builtin_type_mro.py
+9 -2
View File
@@ -1,22 +1,29 @@
class X():
class X:
pass
class Y():
class Y:
pass
class A(X, Y):
pass
assert (A, X, Y, object) == A.__mro__
class B(X, Y):
pass
assert (B, X, Y, object) == B.__mro__
class C(A, B):
pass
assert (C, A, B, X, Y, object) == C.__mro__
assert type.__mro__ == (type, object)
extra_tests/snippets/builtin_zip.py
+7 -3
View File
@@ -1,9 +1,13 @@
assert list(zip(['a', 'b', 'c'], range(3), [9, 8, 7, 99])) == [('a', 0, 9), ('b', 1, 8), ('c', 2, 7)]
assert list(zip(["a", "b", "c"], range(3), [9, 8, 7, 99])) == [
("a", 0, 9),
("b", 1, 8),
("c", 2, 7),
]
assert list(zip(['a', 'b', 'c'])) == [('a',), ('b',), ('c',)]
assert list(zip(["a", "b", "c"])) == [("a",), ("b",), ("c",)]
assert list(zip()) == []
assert list(zip(*zip(['a', 'b', 'c'], range(1, 4)))) == [('a', 'b', 'c'), (1, 2, 3)]
assert list(zip(*zip(["a", "b", "c"], range(1, 4)))) == [("a", "b", "c"), (1, 2, 3)]
# test infinite iterator
extra_tests/snippets/builtins_module.py
+9 -8
View File
@@ -1,25 +1,26 @@
from testutils import assert_raises
assert '__builtins__' in globals()
assert "__builtins__" in globals()
# assert type(__builtins__).__name__ == 'module'
with assert_raises(AttributeError):
__builtins__.__builtins__
assert __builtins__.__name__ == "builtins"
import builtins
assert builtins.__name__ == "builtins"
__builtins__.x = 'new'
assert x == 'new' # noqa: F821
__builtins__.x = "new"
assert x == "new" # noqa: F821
exec('assert "__builtins__" in globals()', dict())
exec('assert __builtins__ == 7', {'__builtins__': 7})
exec('assert not isinstance(__builtins__, dict)')
exec('assert isinstance(__builtins__, dict)', {})
exec("assert __builtins__ == 7", {"__builtins__": 7})
exec("assert not isinstance(__builtins__, dict)")
exec("assert isinstance(__builtins__, dict)", {})
namespace = {}
exec('', namespace)
assert namespace['__builtins__'] == __builtins__.__dict__
exec("", namespace)
assert namespace["__builtins__"] == __builtins__.__dict__
# with assert_raises(NameError):
# exec('print(__builtins__)', {'__builtins__': {}})
extra_tests/snippets/code_co_consts.py
+12 -4
View File
@@ -1,5 +1,6 @@
from asyncio import sleep
def f():
def g():
return 1
@@ -7,25 +8,32 @@ def f():
assert g.__code__.co_consts[0] == None
return 2
assert f.__code__.co_consts[0] == None
def generator():
yield 1
yield 2
yield 1
yield 2
assert generator().gi_code.co_consts[0] == None
async def async_f():
await sleep(1)
return 1
await sleep(1)
return 1
assert async_f.__code__.co_consts[0] == None
lambda_f = lambda: 0
assert lambda_f.__code__.co_consts[0] == None
class cls:
def f():
return 1
assert cls().f.__code__.co_consts[0] == None
extra_tests/snippets/dir_main/__main__.py
+1 -1
View File
@@ -1 +1 @@
print('Hello')
print("Hello")
extra_tests/snippets/example_fizzbuzz.py
+1
View File
@@ -8,6 +8,7 @@ def fizzbuzz(n):
else:
return str(n)
n = 1
while n < 10:
print(fizzbuzz(n))
extra_tests/snippets/example_interactive.py
+7 -5
View File
@@ -1,12 +1,14 @@
c1 = compile("1 + 1", "", 'eval')
c1 = compile("1 + 1", "", "eval")
code_class = type(c1)
def f(x, y, *args, power=1, **kwargs):
print("Constant String", 2, None, (2, 4))
assert code_class == type(c1)
z = x * y
return z ** power
return z**power
c2 = f.__code__
# print(c2)
@@ -19,12 +21,12 @@ assert "Constant String" in c2.co_consts, c2.co_consts
print(c2.co_consts)
assert 2 in c2.co_consts, c2.co_consts
assert "example_interactive.py" in c2.co_filename
assert c2.co_firstlineno == 5, str(c2.co_firstlineno)
assert c2.co_firstlineno == 6, str(c2.co_firstlineno)
# assert isinstance(c2.co_flags, int) # 'OPTIMIZED, NEWLOCALS, NOFREE'
# assert c2.co_freevars == (), str(c2.co_freevars)
assert c2.co_kwonlyargcount == 1, (c2.co_kwonlyargcount)
assert c2.co_kwonlyargcount == 1, c2.co_kwonlyargcount
# assert c2.co_lnotab == 0, c2.co_lnotab # b'\x00\x01' # Line number table
assert c2.co_name == 'f', c2.co_name
assert c2.co_name == "f", c2.co_name
# assert c2.co_names == ('code_class', 'type', 'c1', 'AssertionError'), c2.co_names # , c2.co_names
# assert c2.co_nlocals == 4, c2.co_nlocals #
# assert c2.co_stacksize == 2, 'co_stacksize',
extra_tests/snippets/forbidden_instantiation.py
+30 -8
View File
@@ -1,19 +1,41 @@
from typing import Type
from types import (
GeneratorType, CoroutineType, AsyncGeneratorType, BuiltinFunctionType,
BuiltinMethodType, WrapperDescriptorType, MethodWrapperType, MethodDescriptorType,
ClassMethodDescriptorType, FrameType, GetSetDescriptorType, MemberDescriptorType
GeneratorType,
CoroutineType,
AsyncGeneratorType,
BuiltinFunctionType,
BuiltinMethodType,
WrapperDescriptorType,
MethodWrapperType,
MethodDescriptorType,
ClassMethodDescriptorType,
FrameType,
GetSetDescriptorType,
MemberDescriptorType,
)
from testutils import assert_raises
def check_forbidden_instantiation(typ, reverse=False):
f = reversed if reverse else iter
with assert_raises(TypeError):
type(f(typ()))()
dict_values, dict_items = lambda: {}.values(), lambda: {}.items()
# types with custom forward iterators
iter_types = [list, set, str, bytearray, bytes, dict, tuple, lambda: range(0), dict_items, dict_values]
iter_types = [
list,
set,
str,
bytearray,
bytes,
dict,
tuple,
lambda: range(0),
dict_items,
dict_values,
]
# types with custom backwards iterators
reviter_types = [list, dict, lambda: range(0), dict_values, dict_items]
# internal types:
@@ -22,14 +44,14 @@ internal_types = [
CoroutineType,
AsyncGeneratorType,
BuiltinFunctionType,
BuiltinMethodType, # same as MethodWrapperType
BuiltinMethodType, # same as MethodWrapperType
WrapperDescriptorType,
MethodWrapperType,
MethodDescriptorType,
ClassMethodDescriptorType,
FrameType,
GetSetDescriptorType, # same as MemberDescriptorType
MemberDescriptorType
GetSetDescriptorType, # same as MemberDescriptorType
MemberDescriptorType,
]
for typ in iter_types:
@@ -38,4 +60,4 @@ for typ in reviter_types:
check_forbidden_instantiation(typ, reverse=True)
for typ in internal_types:
with assert_raises(TypeError):
typ()
typ()
extra_tests/snippets/frozen.py
+1
View File
@@ -1,2 +1,3 @@
import __hello__
assert __hello__.initialized == True
extra_tests/snippets/import.py
+26 -21
View File
@@ -4,6 +4,7 @@ from import_target import func as aliased_func, other_func as aliased_other_func
from import_star import *
import import_mutual1
assert import_target.X == import_target.func()
assert import_target.X == func()
@@ -17,56 +18,60 @@ assert import_target.Y == aliased.Y
assert import_target.X == aliased_func()
assert import_target.Y == aliased_other_func()
assert STAR_IMPORT == '123'
assert STAR_IMPORT == "123"
try:
from import_target import func, unknown_name
raise AssertionError('`unknown_name` does not cause an exception')
raise AssertionError("`unknown_name` does not cause an exception")
except ImportError:
pass
try:
import mymodule
except ModuleNotFoundError as exc:
assert exc.name == 'mymodule'
assert exc.name == "mymodule"
test = __import__("import_target")
assert test.X == import_target.X
import builtins
class OverrideImportContext():
def __enter__(self):
self.original_import = builtins.__import__
def __exit__(self, exc_type, exc_val, exc_tb):
builtins.__import__ = self.original_import
class OverrideImportContext:
def __enter__(self):
self.original_import = builtins.__import__
def __exit__(self, exc_type, exc_val, exc_tb):
builtins.__import__ = self.original_import
with OverrideImportContext():
def fake_import(name, globals=None, locals=None, fromlist=(), level=0):
return len(name)
builtins.__import__ = fake_import
import test
assert test == 4
def fake_import(name, globals=None, locals=None, fromlist=(), level=0):
return len(name)
builtins.__import__ = fake_import
import test
assert test == 4
# TODO: Once we can determine current directory, use that to construct this
# path:
#import sys
#sys.path.append("snippets/import_directory")
#import nested_target
# import sys
# sys.path.append("snippets/import_directory")
# import nested_target
#try:
# try:
# X
#except NameError:
# except NameError:
# pass
#else:
# else:
# raise AssertionError('X should not be imported')
from testutils import assert_raises
with assert_raises(SyntaxError):
exec('import')
exec("import")
extra_tests/snippets/import_file.py
+2 -1
View File
@@ -1,4 +1,5 @@
import os
def import_file():
assert os.path.basename(__file__) == "import_file.py"
assert os.path.basename(__file__) == "import_file.py"
extra_tests/snippets/import_mutual1.py
-2
View File
@@ -1,4 +1,2 @@
# Mutual recursive import:
import import_mutual2
extra_tests/snippets/import_mutual2.py
-1
View File
@@ -1,3 +1,2 @@
# Mutual recursive import:
import import_mutual1
extra_tests/snippets/import_star.py
+1 -1
View File
@@ -1,3 +1,3 @@
# This is used by import.py; the two should be modified in concert
STAR_IMPORT = '123'
STAR_IMPORT = "123"
extra_tests/snippets/import_target.py
+4 -2
View File
@@ -1,10 +1,12 @@
# This is used by import.py; the two should be modified in concert
X = '123'
Y = 'abc'
X = "123"
Y = "abc"
def func():
return X
def other_func():
return Y
extra_tests/snippets/intro/3.1.1.1.py
+4 -4
View File
@@ -1,8 +1,8 @@
assert 2 + 2 == 4
assert 50 - 5*6 == 20
assert 50 - 5 * 6 == 20
assert (50 - 5*6) / 4 == 5 # This will crash
assert (50 - 5*6) / 4 == 5.0
assert (50 - 5 * 6) / 4 == 5 # This will crash
assert (50 - 5 * 6) / 4 == 5.0
assert 8 / 5 == 1.6 # division always returns a floating point number
assert 8 / 5 == 1.6 # division always returns a floating point number
extra_tests/snippets/intro/3.1.1.3.py
+2 -2
View File
@@ -1,3 +1,3 @@
assert 25 == 5 ** 2 # 5 squared
assert 25 == 5**2 # 5 squared
assert 128 == 2 ** 7 # 2 to the power of 7
assert 128 == 2**7 # 2 to the power of 7
extra_tests/snippets/intro/3.1.2.1.py
+3 -4
View File
@@ -1,7 +1,6 @@
assert 'spam eggs' == 'spam eggs' # single quotes
assert "doesn't" == 'doesn\'t' # use \' to escape the single quote...
assert "spam eggs" == "spam eggs" # single quotes
assert "doesn't" == "doesn't" # use \' to escape the single quote...
assert "doesn't" == "doesn't" # ...or use double quotes instead
assert '"Yes," he said.' == '"Yes," he said.'
assert '"Yes," he said.' == "\"Yes,\" he said."
assert '"Yes," he said.' == '"Yes," he said.'
assert '"Isn\'t," she said.' == '"Isn\'t," she said.'
extra_tests/snippets/intro/3.1.2.10.py
+6 -6
View File
@@ -1,6 +1,6 @@
word = 'Python'
assert 'P' == word[0] # character in position 0
assert 'n' == word[5] # character in position 5
assert 'n' == word[-1] # last character
assert 'o' == word[-2] # second-last character
assert 'P' == word[-6]
word = "Python"
assert "P" == word[0] # character in position 0
assert "n" == word[5] # character in position 5
assert "n" == word[-1] # last character
assert "o" == word[-2] # second-last character
assert "P" == word[-6]
extra_tests/snippets/intro/3.1.2.3.py
+1 -1
View File
@@ -1 +1 @@
print('C:\some\name')
print("C:\some\name")
extra_tests/snippets/intro/3.1.2.5.py
+1 -1
View File
@@ -1 +1 @@
assert 'unununium' == 3 * 'un' + 'ium'
assert "unununium" == 3 * "un" + "ium"
extra_tests/snippets/intro/3.1.2.6.py
+1 -1
View File
@@ -1 +1 @@
assert 'Python' == 'Py' 'thon'
assert "Python" == "Python"
extra_tests/snippets/jit.py
-1
View File
@@ -1,4 +1,3 @@
def foo():
a = 5
return 10 + a
extra_tests/snippets/name.py
+2 -2
View File
@@ -1,9 +1,9 @@
#when name.py is run __name__ should equal to __main__
# when name.py is run __name__ should equal to __main__
assert __name__ == "__main__"
from import_name import import_func
#__name__ should be set to import_func
# __name__ should be set to import_func
import_func()
assert __name__ == "__main__"
extra_tests/snippets/operator_arithmetic.py
+1 -1
View File
@@ -5,7 +5,7 @@ assert -3 % 2 == 1
a = 4
assert a ** 3 == 64
assert a**3 == 64
assert a * 3 == 12
assert a / 2 == 2
assert 2 == a / 2
extra_tests/snippets/operator_cast.py
+12 -12
View File
@@ -1,39 +1,39 @@
x = 1
y = 1.1
assert x+y == 2.1
#print(x+y)
assert x + y == 2.1
# print(x+y)
x = 1.1
y = 1
assert x+y == 2.1
#print(x+y)
assert x + y == 2.1
# print(x+y)
x = 1.1
y = 2.1
assert x+y == 3.2
#print(x+y)
assert x + y == 3.2
# print(x+y)
x = "ab"
y = "cd"
assert x+y == "abcd"
#print(x+y)
assert x + y == "abcd"
# print(x+y)
x = 2
y = 3
assert x**y == 8
#print(x**y)
# print(x**y)
x = 2.0
y = 3
assert x**y == 8.0
#print(x**y)
# print(x**y)
x = 2
y = 3.0
assert x**y == 8.0
#print(x**y)
# print(x**y)
x = 2.0
y = 3.0
assert x**y == 8.0
#print(x**y)
# print(x**y)
extra_tests/snippets/operator_comparison.py
+22 -19
View File
@@ -13,12 +13,14 @@ assert not 1 < 2 < 3 > 4
assert not 1 < 2 > 3 < 4
assert not 1 > 2 < 3 < 4
def test_type_error(x, y):
assert_raises(TypeError, lambda: x < y)
assert_raises(TypeError, lambda: x <= y)
assert_raises(TypeError, lambda: x > y)
assert_raises(TypeError, lambda: x >= y)
test_type_error([], 0)
test_type_error((), 0)
@@ -34,6 +36,7 @@ assert 1e308 == int(1e308)
# floats that cannot be converted to big ints shouldn’t crash the vm
import math
assert not (10**500 == math.inf)
assert not (math.inf == 10**500)
assert not (10**500 == math.nan)
@@ -41,23 +44,23 @@ assert not (math.nan == 10**500)
# comparisons
# floats with worse than integer precision
assert 2.**54 > 2**54 - 1
assert 2.**54 < 2**54 + 1
assert 2.**54 >= 2**54 - 1
assert 2.**54 <= 2**54 + 1
assert 2.**54 == 2**54
assert not 2.**54 == 2**54 + 1
assert 2.0**54 > 2**54 - 1
assert 2.0**54 < 2**54 + 1
assert 2.0**54 >= 2**54 - 1
assert 2.0**54 <= 2**54 + 1
assert 2.0**54 == 2**54
assert not 2.0**54 == 2**54 + 1
# inverse operands
assert 2**54 - 1 < 2.**54
assert 2**54 + 1 > 2.**54
assert 2**54 - 1 <= 2.**54
assert 2**54 + 1 >= 2.**54
assert 2**54 == 2.**54
assert not 2**54 + 1 == 2.**54
assert 2**54 - 1 < 2.0**54
assert 2**54 + 1 > 2.0**54
assert 2**54 - 1 <= 2.0**54
assert 2**54 + 1 >= 2.0**54
assert 2**54 == 2.0**54
assert not 2**54 + 1 == 2.0**54
assert not 2.**54 < 2**54 - 1
assert not 2.**54 > 2**54 + 1
assert not 2.0**54 < 2**54 - 1
assert not 2.0**54 > 2**54 + 1
# sub-int numbers
assert 1.3 > 1
@@ -68,17 +71,17 @@ assert -0.3 < 0
assert -0.3 <= 0
# int out of float range comparisons
assert 10**500 > 2.**54
assert -10**500 < -0.12
assert 10**500 > 2.0**54
assert -(10**500) < -0.12
# infinity and NaN comparisons
assert math.inf > 10**500
assert math.inf >= 10**500
assert not math.inf < 10**500
assert -math.inf < -10*500
assert -math.inf <= -10*500
assert not -math.inf > -10*500
assert -math.inf < -10 * 500
assert -math.inf <= -10 * 500
assert not -math.inf > -10 * 500
assert not math.nan > 123
assert not math.nan < 123
extra_tests/snippets/operator_div.py
+9 -5
View File
@@ -2,7 +2,7 @@ from testutils import assert_raises
assert_raises(ZeroDivisionError, lambda: 5 / 0)
assert_raises(ZeroDivisionError, lambda: 5 / -0.0)
assert_raises(ZeroDivisionError, lambda: 5 / (2-2))
assert_raises(ZeroDivisionError, lambda: 5 / (2 - 2))
assert_raises(ZeroDivisionError, lambda: 5 % 0)
assert_raises(ZeroDivisionError, lambda: 5 // 0)
assert_raises(ZeroDivisionError, lambda: 5.3 // (-0.0))
@@ -18,12 +18,16 @@ assert 2.456984 <= res <= 2.456985
res = 10**3000 / (10**2998 + 5 * 10**2996)
assert 95.238095 <= res <= 95.238096
assert 10**500 / (2*10**(500-308)) == 5e307
assert 10**500 / (10**(500-308)) == 1e308
assert_raises(OverflowError, lambda: 10**500 / (10**(500-309)), _msg='too big result')
assert 10**500 / (2 * 10 ** (500 - 308)) == 5e307
assert 10**500 / (10 ** (500 - 308)) == 1e308
assert_raises(
OverflowError, lambda: 10**500 / (10 ** (500 - 309)), _msg="too big result"
)
# a bit more than f64::MAX = 1.7976931348623157e+308_f64
assert (2 * 10**308) / 2 == 1e308
# when dividing too big int by a float, the operation should fail
assert_raises(OverflowError, lambda: (2 * 10**308) / 2.0, _msg='division of big int by float')
assert_raises(
OverflowError, lambda: (2 * 10**308) / 2.0, _msg="division of big int by float"
)
extra_tests/snippets/operator_membership.py
+3 -2
View File
@@ -46,15 +46,16 @@ assert 3 not in iter([1, 2])
assert 1 in range(0, 2)
assert 3 not in range(0, 2)
# test __contains__ in user objects
class MyNotContainingClass():
class MyNotContainingClass:
pass
assert_raises(TypeError, lambda: 1 in MyNotContainingClass())
class MyContainingClass():
class MyContainingClass:
def __init__(self, value):
self.value = value
extra_tests/snippets/protocol_callable.py
+4 -1
View File
@@ -1,4 +1,4 @@
class Callable():
class Callable:
def __init__(self):
self.count = 0
@@ -6,13 +6,16 @@ class Callable():
self.count += 1
return self.count
c = Callable()
assert 1 == c()
assert 2 == c()
class Inherited(Callable):
pass
i = Inherited()
assert 1 == i()
extra_tests/snippets/protocol_index_bad.py
+12 -10
View File
@@ -1,5 +1,6 @@
""" Test that indexing ops don't hang when an object with a mutating
"""Test that indexing ops don't hang when an object with a mutating
__index__ is used."""
from testutils import assert_raises
from array import array
@@ -15,18 +16,19 @@ class BadIndex:
def run_setslice():
with assert_raises(IndexError):
e[BadIndex()] = 42
e[BadIndex():0:-1] = e
e[0:BadIndex():1] = e
e[0:10:BadIndex()] = e
e[BadIndex() : 0 : -1] = e
e[0 : BadIndex() : 1] = e
e[0 : 10 : BadIndex()] = e
def run_delslice():
del e[BadIndex():0:-1]
del e[0:BadIndex():1]
del e[0:10:BadIndex()]
del e[BadIndex() : 0 : -1]
del e[0 : BadIndex() : 1]
del e[0 : 10 : BadIndex()]
# Check types
instances = [list(), bytearray(), array('b')]
# Check types
instances = [list(), bytearray(), array("b")]
for e in instances:
run_setslice()
run_delslice()
run_delslice()
extra_tests/snippets/protocol_iterable.py
+18 -4
View File
@@ -1,5 +1,6 @@
from testutils import assert_raises
def test_container(x):
assert 3 in x
assert 4 not in x
@@ -10,27 +11,40 @@ def test_container(x):
lst.extend(x)
assert lst == [0, 1, 2, 3]
class C:
def __iter__(self):
return iter([0, 1, 2, 3])
test_container(C())
class C:
def __getitem__(self, x):
return (0, 1, 2, 3)[x] # raises IndexError on x==4
return (0, 1, 2, 3)[x] # raises IndexError on x==4
test_container(C())
class C:
def __getitem__(self, x):
if x > 3:
raise StopIteration
return x
test_container(C())
class C: pass
class C:
pass
assert_raises(TypeError, lambda: 5 in C())
assert_raises(TypeError, iter, C)
it = iter([1,2,3,4,5])
it = iter([1, 2, 3, 4, 5])
call_it = iter(lambda: next(it), 4)
assert list(call_it) == [1,2,3]
assert list(call_it) == [1, 2, 3]
extra_tests/snippets/protocol_iternext.py
+3 -5
View File
@@ -1,5 +1,3 @@
ls = [1, 2, 3]
i = iter(ls)
@@ -7,10 +5,10 @@ assert i.__next__() == 1
assert i.__next__() == 2
assert next(i) == 3
assert next(i, 'w00t') == 'w00t'
assert next(i, "w00t") == "w00t"
s = '你好'
s = "你好"
i = iter(s)
i.__setstate__(1)
assert i.__next__() == '好'
assert i.__next__() == "好"
assert i.__reduce__()[2] == 2
extra_tests/snippets/recursion.py
+2
View File
@@ -1,8 +1,10 @@
from testutils import assert_raises
class Foo(object):
pass
Foo.__repr__ = Foo.__str__
foo = Foo()
extra_tests/snippets/stdlib_abc_number.py
+1 -1
View File
@@ -71,4 +71,4 @@ assert 1_2.3_4 == 12.34
assert 1_2.3_4e0_0 == 12.34
with assert_raises(SyntaxError):
eval('1__2')
eval("1__2")
extra_tests/snippets/stdlib_array.py
+21 -13
View File
@@ -23,6 +23,7 @@ assert a.__ne__(b) is False
b = array("B", [3, 2, 1, 0])
assert a.__ne__(b) is True
def test_float_with_integer_input():
f = array("f", [0, 1, 2.0, 3.0])
f.append(4)
@@ -33,10 +34,11 @@ def test_float_with_integer_input():
f[0] = -2
assert f == array("f", [-2, 0, 2, 3, 4])
test_float_with_integer_input()
# slice assignment step overflow behaviour test
T = 'I'
T = "I"
a = array(T, range(10))
b = array(T, [100])
a[::9999999999] = b
@@ -57,9 +59,10 @@ assert a == array(T, [1, 2, 3, 4, 5, 6, 7, 8])
del a[0:0:-9999999999]
assert a == array(T, [1, 2, 3, 4, 5, 6, 7, 8])
def test_float_with_nan():
f = float('nan')
a = array('f')
f = float("nan")
a = array("f")
a.append(f)
assert not (a == a)
assert a != a
@@ -68,30 +71,35 @@ def test_float_with_nan():
assert not (a > a)
assert not (a >= a)
test_float_with_nan()
def test_different_type_cmp():
a = array('i', [-1, -2, -3, -4])
b = array('I', [1, 2, 3, 4])
c = array('f', [1, 2, 3, 4])
a = array("i", [-1, -2, -3, -4])
b = array("I", [1, 2, 3, 4])
c = array("f", [1, 2, 3, 4])
assert a < b
assert b > a
assert b == c
assert a < c
assert c > a
test_different_type_cmp()
def test_array_frombytes():
a = array('b', [-1, -2])
a = array("b", [-1, -2])
b = bytearray(a.tobytes())
c = array('b', b)
c = array("b", b)
assert a == c
test_array_frombytes()
# test that indexing on an empty array doesn't panic
a = array('b')
a = array("b")
with assert_raises(IndexError):
a[0]
with assert_raises(IndexError):
@@ -99,21 +107,21 @@ with assert_raises(IndexError):
with assert_raises(IndexError):
del a[42]
test_str = '🌉abc🌐def🌉🌐'
u = array('u', test_str)
test_str = "🌉abc🌐def🌉🌐"
u = array("u", test_str)
# skip as 2 bytes character environment with CPython is failing the test
if u.itemsize >= 4:
assert u.__reduce_ex__(1)[1][1] == list(test_str)
assert loads(dumps(u, 1)) == loads(dumps(u, 3))
# test array name
a = array('b', [])
a = array("b", [])
assert str(a.__class__.__name__) == "array"
# test arrayiterator name
i = iter(a)
assert str(i.__class__.__name__) == "arrayiterator"
# teset array.__contains__
a = array('B', [0])
a = array("B", [0])
assert a.__contains__(0)
assert not a.__contains__(1)
extra_tests/snippets/stdlib_ast.py
+7 -8
View File
@@ -1,5 +1,5 @@
import ast
print(ast)
source = """
@@ -11,30 +11,29 @@ n = ast.parse(source)
print(n)
print(n.body)
print(n.body[0].name)
assert n.body[0].name == 'foo'
assert n.body[0].name == "foo"
foo = n.body[0]
assert foo.lineno == 2
print(foo.body)
assert len(foo.body) == 2
print(foo.body[0])
print(foo.body[0].value.func.id)
assert foo.body[0].value.func.id == 'print'
assert foo.body[0].value.func.id == "print"
assert foo.body[0].lineno == 3
assert foo.body[1].lineno == 4
n = ast.parse("3 < 4 > 5\n")
assert n.body[0].value.left.value == 3
assert 'Lt' in str(n.body[0].value.ops[0])
assert 'Gt' in str(n.body[0].value.ops[1])
assert "Lt" in str(n.body[0].value.ops[0])
assert "Gt" in str(n.body[0].value.ops[1])
assert n.body[0].value.comparators[0].value == 4
assert n.body[0].value.comparators[1].value == 5
n = ast.parse('from ... import a\n')
n = ast.parse("from ... import a\n")
print(n)
i = n.body[0]
assert i.level == 3
assert i.module is None
assert i.names[0].name == 'a'
assert i.names[0].name == "a"
assert i.names[0].asname is None
extra_tests/snippets/stdlib_collections.py
+3 -2
View File
@@ -50,9 +50,10 @@ assert not (d != d)
class BadRepr:
def __repr__(self):
self.d.pop()
return ''
return ""
b = BadRepr()
d = deque([1, b, 2])
b.d = d
repr(d)
repr(d)
extra_tests/snippets/stdlib_collections_deque.py
+21 -19
View File
@@ -5,9 +5,9 @@ from typing import Deque
def test_deque_iterator__new__():
klass = type(iter(deque()))
s = 'abcd'
s = "abcd"
d = klass(deque(s))
assert (list(d) == list(s))
assert list(d) == list(s)
test_deque_iterator__new__()
@@ -17,22 +17,22 @@ def test_deque_iterator__new__positional_index():
klass = type(iter(deque()))
# index between 0 and len
for s in ('abcd', range(200)):
for s in ("abcd", range(200)):
for i in range(len(s)):
d = klass(deque(s), i)
assert (list(d) == list(s)[i:])
assert list(d) == list(s)[i:]
# negative index
for s in ('abcd', range(200)):
for s in ("abcd", range(200)):
for i in range(-100, 0):
d = klass(deque(s), i)
assert (list(d) == list(s))
assert list(d) == list(s)
# index ge len
for s in ('abcd', range(200)):
for s in ("abcd", range(200)):
for i in range(len(s), 400):
d = klass(deque(s), i)
assert (list(d) == list())
assert list(d) == list()
test_deque_iterator__new__positional_index()
@@ -41,10 +41,10 @@ test_deque_iterator__new__positional_index()
def test_deque_iterator__new__not_using_keyword_index():
klass = type(iter(deque()))
for s in ('abcd', range(200)):
for s in ("abcd", range(200)):
for i in range(-100, 400):
d = klass(deque(s), index=i)
assert (list(d) == list(s))
assert list(d) == list(s)
test_deque_iterator__new__not_using_keyword_index()
@@ -54,22 +54,22 @@ def test_deque_reverse_iterator__new__positional_index():
klass = type(reversed(deque()))
# index between 0 and len
for s in ('abcd', range(200)):
for s in ("abcd", range(200)):
for i in range(len(s)):
d = klass(deque(s), i)
assert (list(d) == list(reversed(s))[i:])
assert list(d) == list(reversed(s))[i:]
# negative index
for s in ('abcd', range(200)):
for s in ("abcd", range(200)):
for i in range(-100, 0):
d = klass(deque(s), i)
assert (list(d) == list(reversed(s)))
assert list(d) == list(reversed(s))
# index ge len
for s in ('abcd', range(200)):
for s in ("abcd", range(200)):
for i in range(len(s), 400):
d = klass(deque(s), i)
assert (list(d) == list())
assert list(d) == list()
test_deque_reverse_iterator__new__positional_index()
@@ -78,10 +78,10 @@ test_deque_reverse_iterator__new__positional_index()
def test_deque_reverse_iterator__new__not_using_keyword_index():
klass = type(reversed(deque()))
for s in ('abcd', range(200)):
for s in ("abcd", range(200)):
for i in range(-100, 400):
d = klass(deque(s), index=i)
assert (list(d) == list(reversed(s)))
assert list(d) == list(reversed(s))
test_deque_reverse_iterator__new__not_using_keyword_index()
@@ -89,11 +89,13 @@ test_deque_reverse_iterator__new__not_using_keyword_index()
assert repr(deque()) == "deque([])"
assert repr(deque([1, 2, 3])) == "deque([1, 2, 3])"
class D(deque):
pass
assert repr(D()) == "D([])"
assert repr(D([1, 2, 3])) == "D([1, 2, 3])"
assert_raises(ValueError, lambda: deque().index(10,0,10000000000000000000000000))
assert_raises(ValueError, lambda: deque().index(10, 0, 10000000000000000000000000))
extra_tests/snippets/stdlib_csv.py
+32 -28
View File
@@ -2,44 +2,48 @@ from testutils import assert_raises
import csv
for row in csv.reader(['one,two,three']):
[one, two, three] = row
assert one == 'one'
assert two == 'two'
assert three == 'three'
for row in csv.reader(["one,two,three"]):
[one, two, three] = row
assert one == "one"
assert two == "two"
assert three == "three"
def f():
iter = ['one,two,three', 'four,five,six']
reader = csv.reader(iter)
iter = ["one,two,three", "four,five,six"]
reader = csv.reader(iter)
[one,two,three] = next(reader)
[four,five,six] = next(reader)
[one, two, three] = next(reader)
[four, five, six] = next(reader)
assert one == "one"
assert two == "two"
assert three == "three"
assert four == "four"
assert five == "five"
assert six == "six"
assert one == 'one'
assert two == 'two'
assert three == 'three'
assert four == 'four'
assert five == 'five'
assert six == 'six'
f()
def test_delim():
iter = ['one|two|three', 'four|five|six']
reader = csv.reader(iter, delimiter='|')
iter = ["one|two|three", "four|five|six"]
reader = csv.reader(iter, delimiter="|")
[one,two,three] = next(reader)
[four,five,six] = next(reader)
[one, two, three] = next(reader)
[four, five, six] = next(reader)
assert one == 'one'
assert two == 'two'
assert three == 'three'
assert four == 'four'
assert five == 'five'
assert six == 'six'
assert one == "one"
assert two == "two"
assert three == "three"
assert four == "four"
assert five == "five"
assert six == "six"
with assert_raises(TypeError):
iter = ["one,,two,,three"]
csv.reader(iter, delimiter=",,")
with assert_raises(TypeError):
iter = ['one,,two,,three']
csv.reader(iter, delimiter=',,')
test_delim()
extra_tests/snippets/stdlib_ctypes.py
+90 -25
View File
@@ -9,8 +9,8 @@ from _ctypes import CFuncPtr as _CFuncPtr
from struct import calcsize as _calcsize
assert Array.__class__.__name__ == 'PyCArrayType'
assert Array.__base__.__name__ == '_CData'
assert Array.__class__.__name__ == "PyCArrayType"
assert Array.__base__.__name__ == "_CData"
DEFAULT_MODE = RTLD_LOCAL
if _os.name == "posix" and _sys.platform == "darwin":
@@ -19,13 +19,16 @@ if _os.name == "posix" and _sys.platform == "darwin":
# libraries. OS X 10.3 is Darwin 7, so we check for
# that.
if int(_os.uname().release.split('.')[0]) < 8:
if int(_os.uname().release.split(".")[0]) < 8:
DEFAULT_MODE = RTLD_GLOBAL
from _ctypes import FUNCFLAG_CDECL as _FUNCFLAG_CDECL, \
FUNCFLAG_PYTHONAPI as _FUNCFLAG_PYTHONAPI, \
FUNCFLAG_USE_ERRNO as _FUNCFLAG_USE_ERRNO, \
FUNCFLAG_USE_LASTERROR as _FUNCFLAG_USE_LASTERROR
from _ctypes import (
FUNCFLAG_CDECL as _FUNCFLAG_CDECL,
FUNCFLAG_PYTHONAPI as _FUNCFLAG_PYTHONAPI,
FUNCFLAG_USE_ERRNO as _FUNCFLAG_USE_ERRNO,
FUNCFLAG_USE_LASTERROR as _FUNCFLAG_USE_LASTERROR,
)
def create_string_buffer(init, size=None):
"""create_string_buffer(aBytes) -> character array
@@ -34,7 +37,7 @@ def create_string_buffer(init, size=None):
"""
if isinstance(init, bytes):
if size is None:
size = len(init)+1
size = len(init) + 1
_sys.audit("ctypes.create_string_buffer", init, size)
buftype = c_char.__mul__(size)
print(type(c_char.__mul__(size)))
@@ -50,32 +53,47 @@ def create_string_buffer(init, size=None):
return buf
raise TypeError(init)
def _check_size(typ, typecode=None):
# Check if sizeof(ctypes_type) against struct.calcsize. This
# should protect somewhat against a misconfigured libffi.
from struct import calcsize
if typecode is None:
# Most _type_ codes are the same as used in struct
typecode = typ._type_
actual, required = sizeof(typ), calcsize(typecode)
if actual != required:
raise SystemError("sizeof(%s) wrong: %d instead of %d" % \
(typ, actual, required))
raise SystemError(
"sizeof(%s) wrong: %d instead of %d" % (typ, actual, required)
)
class c_short(_SimpleCData):
_type_ = "h"
_check_size(c_short)
class c_ushort(_SimpleCData):
_type_ = "H"
_check_size(c_ushort)
class c_long(_SimpleCData):
_type_ = "l"
_check_size(c_long)
class c_ulong(_SimpleCData):
_type_ = "L"
_check_size(c_ulong)
if _calcsize("i") == _calcsize("l"):
@@ -83,24 +101,36 @@ if _calcsize("i") == _calcsize("l"):
c_int = c_long
c_uint = c_ulong
else:
class c_int(_SimpleCData):
_type_ = "i"
_check_size(c_int)
class c_uint(_SimpleCData):
_type_ = "I"
_check_size(c_uint)
class c_float(_SimpleCData):
_type_ = "f"
_check_size(c_float)
class c_double(_SimpleCData):
_type_ = "d"
_check_size(c_double)
class c_longdouble(_SimpleCData):
_type_ = "g"
if sizeof(c_longdouble) == sizeof(c_double):
c_longdouble = c_double
@@ -109,54 +139,76 @@ if _calcsize("l") == _calcsize("q"):
c_longlong = c_long
c_ulonglong = c_ulong
else:
class c_longlong(_SimpleCData):
_type_ = "q"
_check_size(c_longlong)
class c_ulonglong(_SimpleCData):
_type_ = "Q"
## def from_param(cls, val):
## return ('d', float(val), val)
## from_param = classmethod(from_param)
_check_size(c_ulonglong)
class c_ubyte(_SimpleCData):
_type_ = "B"
c_ubyte.__ctype_le__ = c_ubyte.__ctype_be__ = c_ubyte
# backward compatibility:
##c_uchar = c_ubyte
_check_size(c_ubyte)
class c_byte(_SimpleCData):
_type_ = "b"
c_byte.__ctype_le__ = c_byte.__ctype_be__ = c_byte
_check_size(c_byte)
class c_char(_SimpleCData):
_type_ = "c"
c_char.__ctype_le__ = c_char.__ctype_be__ = c_char
_check_size(c_char)
class c_char_p(_SimpleCData):
_type_ = "z"
def __repr__(self):
return "%s(%s)" % (self.__class__.__name__, c_void_p.from_buffer(self).value)
_check_size(c_char_p, "P")
class c_void_p(_SimpleCData):
_type_ = "P"
c_voidp = c_void_p # backwards compatibility (to a bug)
c_voidp = c_void_p # backwards compatibility (to a bug)
_check_size(c_void_p)
class c_bool(_SimpleCData):
_type_ = "?"
_check_size(c_bool)
i = c_int(42)
f = c_float(3.14)
# s = create_string_buffer(b'\000' * 32)
assert i.value == 42
assert abs(f.value - 3.14) < 1e-06
assert abs(f.value - 3.14) < 1e-06
if _os.name == "nt":
from _ctypes import LoadLibrary as _dlopen
@@ -164,6 +216,7 @@ if _os.name == "nt":
elif _os.name == "posix":
from _ctypes import dlopen as _dlopen
class CDLL(object):
"""An instance of this class represents a loaded dll/shared
library, exporting functions using the standard C calling
@@ -178,17 +231,23 @@ class CDLL(object):
Calling the functions releases the Python GIL during the call and
reacquires it afterwards.
"""
_func_flags_ = _FUNCFLAG_CDECL
_func_restype_ = c_int
# default values for repr
_name = '<uninitialized>'
_name = "<uninitialized>"
_handle = 0
_FuncPtr = None
def __init__(self, name, mode=DEFAULT_MODE, handle=None,
use_errno=False,
use_last_error=False,
winmode=None):
def __init__(
self,
name,
mode=DEFAULT_MODE,
handle=None,
use_errno=False,
use_last_error=False,
winmode=None,
):
self._name = name
flags = self._func_flags_
if use_errno:
@@ -202,20 +261,22 @@ class CDLL(object):
Otherwise, name is presented to dlopen() as a file argument.
"""
if name and name.endswith(")") and ".a(" in name:
mode |= ( _os.RTLD_MEMBER | _os.RTLD_NOW )
mode |= _os.RTLD_MEMBER | _os.RTLD_NOW
if _os.name == "nt":
if winmode is not None:
mode = winmode
else:
import nt
mode = 4096
if '/' in name or '\\' in name:
if "/" in name or "\\" in name:
self._name = nt._getfullpathname(self._name)
mode |= nt._LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR
class _FuncPtr(_CFuncPtr):
_flags_ = flags
_restype_ = self._func_restype_
self._FuncPtr = _FuncPtr
if handle is None:
@@ -224,13 +285,15 @@ class CDLL(object):
self._handle = handle
def __repr__(self):
return "<%s '%s', handle %x at %#x>" % \
(self.__class__.__name__, self._name,
(self._handle & (_sys.maxsize*2 + 1)),
id(self) & (_sys.maxsize*2 + 1))
return "<%s '%s', handle %x at %#x>" % (
self.__class__.__name__,
self._name,
(self._handle & (_sys.maxsize * 2 + 1)),
id(self) & (_sys.maxsize * 2 + 1),
)
def __getattr__(self, name):
if name.startswith('__') and name.endswith('__'):
if name.startswith("__") and name.endswith("__"):
raise AttributeError(name)
func = self.__getitem__(name)
setattr(self, name, func)
@@ -242,12 +305,13 @@ class CDLL(object):
func.__name__ = name_or_ordinal
return func
class LibraryLoader(object):
def __init__(self, dlltype):
self._dlltype = dlltype
def __getattr__(self, name):
if name[0] == '_':
if name[0] == "_":
raise AttributeError(name)
try:
dll = self._dlltype(name)
@@ -264,6 +328,7 @@ class LibraryLoader(object):
__class_getitem__ = classmethod(_types.GenericAlias)
cdll = LibraryLoader(CDLL)
test_byte_array = create_string_buffer(b"Hello, World!\n")
extra_tests/snippets/stdlib_datetime.py
+27 -13
View File
@@ -19,8 +19,13 @@ from datetime import date, datetime
import time as _time
from testutils import (
assert_raises, assert_equal, assert_true, assert_false, assert_isinstance,
assert_in)
assert_raises,
assert_equal,
assert_true,
assert_false,
assert_isinstance,
assert_in,
)
# An arbitrary collection of objects of non-datetime types, for testing
# mixed-type comparisons.
@@ -40,7 +45,7 @@ NAN = float("nan")
assert_equal(datetime_module.MINYEAR, 1)
assert_equal(datetime_module.MAXYEAR, 9999)
if hasattr(datetime_module, '_divide_and_round'):
if hasattr(datetime_module, "_divide_and_round"):
# def test_divide_and_round(self):
dar = datetime_module._divide_and_round
@@ -68,8 +73,8 @@ if hasattr(datetime_module, '_divide_and_round'):
#############################################################################
# tzinfo tests
class FixedOffset(tzinfo):
class FixedOffset(tzinfo):
def __init__(self, offset, name, dstoffset=42):
if isinstance(offset, int):
offset = timedelta(minutes=offset)
@@ -78,24 +83,30 @@ class FixedOffset(tzinfo):
self.__offset = offset
self.__name = name
self.__dstoffset = dstoffset
def __repr__(self):
return self.__name.lower()
def utcoffset(self, dt):
return self.__offset
def tzname(self, dt):
return self.__name
def dst(self, dt):
return self.__dstoffset
class PicklableFixedOffset(FixedOffset):
class PicklableFixedOffset(FixedOffset):
def __init__(self, offset=None, name=None, dstoffset=None):
FixedOffset.__init__(self, offset, name, dstoffset)
class _TZInfo(tzinfo):
def utcoffset(self, datetime_module):
return random.random()
# class TestTZInfo(unittest.TestCase):
# def test_refcnt_crash_bug_22044(self):
@@ -117,11 +128,14 @@ with assert_raises(NotImplementedError):
with assert_raises(NotImplementedError):
useless.dst(dt)
# def test_subclass_must_override(self):
class NotEnough(tzinfo):
def __init__(self, offset, name):
self.__offset = offset
self.__name = name
assert_true(issubclass(NotEnough, tzinfo))
ne = NotEnough(3, "NotByALongShot")
assert_isinstance(ne, tzinfo)
@@ -138,14 +152,14 @@ if sys.platform.startswith("linux"):
# XXX: bug #1302
# def test_normal(self):
#fo = FixedOffset(3, "Three")
#assert_isinstance(fo, tzinfo)
#for dt in datetime.now(), None:
# fo = FixedOffset(3, "Three")
# assert_isinstance(fo, tzinfo)
# for dt in datetime.now(), None:
# assert_equal(fo.utcoffset(dt), timedelta(minutes=3))
# assert_equal(fo.tzname(dt), "Three")
# assert_equal(fo.dst(dt), timedelta(minutes=42))
'''
"""
class TestTimeZone(unittest.TestCase):
def setUp(self):
@@ -277,17 +291,17 @@ class TestTimeZone(unittest.TestCase):
tz = timezone.utc
tz_copy = copy.deepcopy(tz)
self.assertIs(tz_copy, tz)
'''
"""
#############################################################################
# Base class for testing a particular aspect of timedelta, time, date and
# datetime comparisons.
# class HarmlessMixedComparison:
# Test that __eq__ and __ne__ don't complain for mixed-type comparisons.
# Test that __eq__ and __ne__ don't complain for mixed-type comparisons.
# Subclasses must define 'theclass', and theclass(1, 1, 1) must be a
# legit constructor.
# Subclasses must define 'theclass', and theclass(1, 1, 1) must be a
# legit constructor.
for theclass in timedelta, date, time:
# def test_harmless_mixed_comparison(self):
extra_tests/snippets/stdlib_dir_module.py
+6 -4
View File
@@ -1,13 +1,14 @@
from testutils import assert_equal
import dir_module
assert dir_module.value == 5
assert dir_module.value2 == 7
try:
dir_module.unknown_attr
except AttributeError as e:
assert 'dir_module' in str(e)
assert "dir_module" in str(e)
else:
assert False
@@ -15,7 +16,7 @@ del dir_module.__name__
try:
dir_module.unknown_attr
except AttributeError as e:
assert 'dir_module' not in str(e)
assert "dir_module" not in str(e)
else:
assert False
@@ -23,9 +24,10 @@ dir_module.__name__ = 1
try:
dir_module.unknown_attr
except AttributeError as e:
assert 'dir_module' not in str(e)
assert "dir_module" not in str(e)
else:
assert False
from dir_module import dir_module_inner
assert dir_module_inner.__name__ == 'dir_module.dir_module_inner'
assert dir_module_inner.__name__ == "dir_module.dir_module_inner"
extra_tests/snippets/stdlib_dis.py
+22 -5
View File
@@ -2,37 +2,53 @@ import dis
dis.dis(compile("5 + x + 5 or 2", "", "eval"))
print("\n")
dis.dis(compile("""
dis.dis(
compile(
"""
def f(x):
return 1
""", "", "exec"))
""",
"",
"exec",
)
)
print("\n")
dis.dis(compile("""
dis.dis(
compile(
"""
if a:
1 or 2
elif x == 'hello':
3
else:
4
""", "", "exec"))
""",
"",
"exec",
)
)
print("\n")
dis.dis(compile("f(x=1, y=2)", "", "eval"))
print("\n")
def f():
with g(): # noqa: F821
try:
for a in {1: 4, 2: 5}:
yield [True and False or True, []]
except Exception:
raise not ValueError({1 for i in [1,2,3]})
raise not ValueError({1 for i in [1, 2, 3]})
dis.dis(f)
class A(object):
def f():
x += 1 # noqa: F821
pass
def g():
for i in range(5):
if i:
@@ -40,5 +56,6 @@ class A(object):
else:
break
print("A.f\n")
dis.dis(A.f)
extra_tests/snippets/stdlib_functools.py
+19 -7
View File
@@ -1,6 +1,7 @@
from functools import reduce
from testutils import assert_raises
class Squares:
def __init__(self, max):
self.max = max
@@ -10,21 +11,24 @@ class Squares:
return len(self.sofar)
def __getitem__(self, i):
if not 0 <= i < self.max: raise IndexError
if not 0 <= i < self.max:
raise IndexError
n = len(self.sofar)
while n <= i:
self.sofar.append(n*n)
self.sofar.append(n * n)
n += 1
return self.sofar[i]
def add(a, b):
return a + b
assert reduce(add, ['a', 'b', 'c']) == 'abc'
assert reduce(add, ['a', 'b', 'c'], str(42)) == '42abc'
assert reduce(add, [['a', 'c'], [], ['d', 'w']], []) == ['a','c','d','w']
assert reduce(add, [['a', 'c'], [], ['d', 'w']], []) == ['a','c','d','w']
assert reduce(lambda x, y: x*y, range(2, 21), 1) == 2432902008176640000
assert reduce(add, ["a", "b", "c"]) == "abc"
assert reduce(add, ["a", "b", "c"], str(42)) == "42abc"
assert reduce(add, [["a", "c"], [], ["d", "w"]], []) == ["a", "c", "d", "w"]
assert reduce(add, [["a", "c"], [], ["d", "w"]], []) == ["a", "c", "d", "w"]
assert reduce(lambda x, y: x * y, range(2, 21), 1) == 2432902008176640000
assert reduce(add, Squares(10)) == 285
assert reduce(add, Squares(10), 0) == 285
assert reduce(add, Squares(0), 0) == 0
@@ -40,32 +44,40 @@ with assert_raises(TypeError):
with assert_raises(TypeError):
reduce(42, 42, 42)
class TestFailingIter:
def __iter__(self):
raise RuntimeError
with assert_raises(RuntimeError):
reduce(add, TestFailingIter())
assert reduce(add, [], None) == None
assert reduce(add, [], 42) == 42
class BadSeq:
def __getitem__(self, index):
raise ValueError
with assert_raises(ValueError):
reduce(42, BadSeq())
# Test reduce()'s use of iterators.
class SequenceClass:
def __init__(self, n):
self.n = n
def __getitem__(self, i):
if 0 <= i < self.n:
return i
else:
raise IndexError
assert reduce(add, SequenceClass(5)) == 10
assert reduce(add, SequenceClass(5), 42) == 52
with assert_raises(TypeError):
Loaded 100 of 138 files, more files were not shown because too many files have changed in this diff. Show more