You've already forked python-uncompyle6
mirror of
https://github.com/rocky/python-uncompyle6.git
synced 2025-08-03 00:45:53 +08:00
129 lines
3.6 KiB
Python
129 lines
3.6 KiB
Python
# std
|
|
import string
|
|
# 3rd party
|
|
from hypothesis import given, assume, strategies as st
|
|
import pytest
|
|
# uncompyle
|
|
from validate import validate_uncompyle
|
|
|
|
|
|
alpha = st.sampled_from(string.ascii_lowercase)
|
|
numbers = st.sampled_from(string.digits)
|
|
alphanum = st.sampled_from(string.ascii_lowercase + string.digits)
|
|
expressions = st.sampled_from([x for x in string.ascii_lowercase + string.digits] + ['x+1'])
|
|
|
|
|
|
@st.composite
|
|
def function_calls(draw):
|
|
"""
|
|
Strategy factory for generating function calls.
|
|
|
|
:param draw: Callable which draws examples from other strategies.
|
|
|
|
:return: The function call text.
|
|
"""
|
|
list1 = st.lists(alpha, min_size=0, max_size=1)
|
|
list3 = st.lists(alpha, min_size=0, max_size=3)
|
|
|
|
positional_args = draw(list3)
|
|
named_args = [x + '=0' for x in draw(list3)]
|
|
star_args = ['*' + x for x in draw(list1)]
|
|
double_star_args = ['**' + x for x in draw(list1)]
|
|
|
|
arguments = positional_args + named_args + star_args + double_star_args
|
|
draw(st.randoms()).shuffle(arguments)
|
|
arguments = ','.join(arguments)
|
|
|
|
function_call = 'fn({arguments})'.format(arguments=arguments)
|
|
try:
|
|
# TODO: Figure out the exact rules for ordering of positional, named,
|
|
# star args, double star args and in which versions the various
|
|
# types of arguments are supported so we don't need to check that the
|
|
# expression compiles like this.
|
|
compile(function_call, '<string>', 'single')
|
|
except:
|
|
assume(False)
|
|
return function_call
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_CALL_FUNCTION():
|
|
validate_uncompyle("fn(w,m,f)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_BUILD_CONST_KEY_MAP_BUILD_MAP_UNPACK_WITH_CALL_BUILD_TUPLE_CALL_FUNCTION_EX():
|
|
validate_uncompyle("fn(w=0,m=0,**v)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_BUILD_MAP_BUILD_MAP_UNPACK_WITH_CALL_BUILD_TUPLE_CALL_FUNCTION_EX():
|
|
validate_uncompyle("fn(a=0,**g)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_CALL_FUNCTION_KW():
|
|
validate_uncompyle("fn(j=0)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_CALL_FUNCTION_EX():
|
|
validate_uncompyle("fn(*g,**j)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_BUILD_MAP_CALL_FUNCTION_EX():
|
|
validate_uncompyle("fn(*z,u=0)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_BUILD_TUPLE_CALL_FUNCTION_EX():
|
|
validate_uncompyle("fn(**a)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_BUILD_MAP_BUILD_TUPLE_BUILD_TUPLE_UNPACK_WITH_CALL_CALL_FUNCTION_EX():
|
|
validate_uncompyle("fn(b,b,b=0,*a)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_BUILD_TUPLE_BUILD_TUPLE_UNPACK_WITH_CALL_CALL_FUNCTION_EX():
|
|
validate_uncompyle("fn(*c,v)")
|
|
|
|
|
|
@pytest.mark.xfail()
|
|
def test_BUILD_CONST_KEY_MAP_CALL_FUNCTION_EX():
|
|
validate_uncompyle("fn(i=0,y=0,*p)")
|
|
|
|
|
|
@pytest.mark.skip(reason='skipping property based test until all individual tests are passing')
|
|
@given(function_calls())
|
|
def test_function_call(function_call):
|
|
validate_uncompyle(function_call)
|
|
|
|
|
|
examples = set()
|
|
generate_examples = False
|
|
|
|
|
|
@pytest.mark.skipif(not generate_examples, reason='not generating examples')
|
|
@given(function_calls())
|
|
def test_generate_hypothesis(function_call):
|
|
examples.add(function_call)
|
|
|
|
|
|
@pytest.mark.skipif(not generate_examples, reason='not generating examples')
|
|
def test_generate_examples():
|
|
import dis
|
|
example_opcodes = {}
|
|
for example in examples:
|
|
opcodes = tuple(sorted(set(
|
|
instruction.opname
|
|
for instruction in dis.Bytecode(example)
|
|
if instruction.opname not in ('LOAD_CONST', 'LOAD_NAME', 'RETURN_VALUE')
|
|
)))
|
|
example_opcodes[opcodes] = example
|
|
for k, v in example_opcodes.items():
|
|
print('def test_' + '_'.join(k) + '():\n validate_uncompyle("' + v + '")\n\n')
|
|
return
|