import gc

import os

import pickle

import platform

import sys

import types

import weakref

from datetime import date

from datetime import datetime

from decimal import Decimal

import pytest

PYPY = '__pypy__' in sys.builtin_module_names

graalpyxfail = pytest.mark.xfail('sys.implementation.name == "graalpy"')

OBJECTS_CODE = """

class TargetBaseClass(object):

"documentation"

class Target(TargetBaseClass):

"documentation"

def target():

"documentation"

pass

"""

objects = types.ModuleType('objects')

exec(OBJECTS_CODE, objects.__dict__, objects.__dict__)

def test_round(lop):

proxy = lop.Proxy(lambda: 1.2)

assert round(proxy) == 1

def test_round_ndigits(lop):

proxy = lop.Proxy(lambda: 1.49494)

assert round(proxy, 3) == 1.495

def test_attributes(lop):

def function1(*args, **kwargs):

return args, kwargs

function2 = lop.Proxy(lambda: function1)

assert function2.__wrapped__ == function1

def test_get_wrapped(lop):

def function1(*args, **kwargs):

return args, kwargs

function2 = lop.Proxy(lambda: function1)

assert function2.__wrapped__ == function1

function3 = lop.Proxy(lambda: function2)

assert function3.__wrapped__ == function1

def test_set_wrapped(lop):

def function1(*args, **kwargs):

return args, kwargs

function2 = lop.Proxy(lambda: function1)

assert function2 == function1

assert function2.__wrapped__ is function1

assert function2.__name__ == function1.__name__

assert function2.__qualname__ == function1.__qualname__

function2.__wrapped__ = None

assert not hasattr(function1, '__wrapped__')

assert function2 == None # noqa

assert function2.__wrapped__ is None

assert not hasattr(function2, '__name__')

assert not hasattr(function2, '__qualname__')

def function3(*args, **kwargs):

return args, kwargs

function2.__wrapped__ = function3

assert function2 == function3

assert function2.__wrapped__ == function3

assert function2.__name__ == function3.__name__

assert function2.__qualname__ == function3.__qualname__

def test_wrapped_attribute(lop):

def function1(*args, **kwargs):

return args, kwargs

function2 = lop.Proxy(lambda: function1)

function2.variable = True

assert hasattr(function1, 'variable')

assert hasattr(function2, 'variable')

assert function2.variable is True

del function2.variable

assert not hasattr(function1, 'variable')

assert not hasattr(function2, 'variable')

assert getattr(function2, 'variable', None) is None

def test_class_object_name(lop):

# Test preservation of class __name__ attribute.

target = objects.Target

wrapper = lop.Proxy(lambda: target)

assert wrapper.__name__ == target.__name__

def test_class_object_qualname(lop):

# Test preservation of class __qualname__ attribute.

target = objects.Target

wrapper = lop.Proxy(lambda: target)

try:

__qualname__ = target.__qualname__

except AttributeError:

pass

else:

assert wrapper.__qualname__ == __qualname__

@pytest.mark.xfail_subclass

def test_class_module_name(lop):

# Test preservation of class __module__ attribute.

target = objects.Target

wrapper = lop.Proxy(lambda: target)

assert wrapper.__module__ == target.__module__

@pytest.mark.xfail_subclass

def test_class_doc_string(lop):

# Test preservation of class __doc__ attribute.

target = objects.Target

wrapper = lop.Proxy(lambda: target)

assert wrapper.__doc__ == target.__doc__

@pytest.mark.xfail_subclass

def test_instance_module_name(lop):

# Test preservation of instance __module__ attribute.

target = objects.Target()

wrapper = lop.Proxy(lambda: target)

assert wrapper.__module__ == target.__module__

@pytest.mark.xfail_subclass

def test_instance_doc_string(lop):

# Test preservation of instance __doc__ attribute.

target = objects.Target()

wrapper = lop.Proxy(lambda: target)

assert wrapper.__doc__ == target.__doc__

def test_function_object_name(lop):

# Test preservation of function __name__ attribute.

target = objects.target

wrapper = lop.Proxy(lambda: target)

assert wrapper.__name__ == target.__name__

def test_function_object_qualname(lop):

# Test preservation of function __qualname__ attribute.

target = objects.target

wrapper = lop.Proxy(lambda: target)

try:

__qualname__ = target.__qualname__

except AttributeError:

pass

else:

assert wrapper.__qualname__ == __qualname__

@pytest.mark.xfail_subclass

def test_function_module_name(lop):

# Test preservation of function __module__ attribute.

target = objects.target

wrapper = lop.Proxy(lambda: target)

assert wrapper.__module__ == target.__module__

@pytest.mark.xfail_subclass

def test_function_doc_string(lop):

# Test preservation of function __doc__ attribute.

target = objects.target

wrapper = lop.Proxy(lambda: target)

assert wrapper.__doc__ == target.__doc__

@graalpyxfail

def test_class_of_class(lop):

# Test preservation of class __class__ attribute.

target = objects.Target

wrapper = lop.Proxy(lambda: target)

assert wrapper.__class__ is target.__class__

assert isinstance(wrapper, type(target))

def test_revert_class_proxying(lop):

class ProxyWithOldStyleIsInstance(lop.Proxy):

__class__ = object.__dict__['__class__']

target = objects.Target()

wrapper = ProxyWithOldStyleIsInstance(lambda: target)

assert wrapper.__class__ is ProxyWithOldStyleIsInstance

assert isinstance(wrapper, ProxyWithOldStyleIsInstance)

assert not isinstance(wrapper, objects.Target)

assert not isinstance(wrapper, objects.TargetBaseClass)

class ProxyWithOldStyleIsInstance2(ProxyWithOldStyleIsInstance):

pass

wrapper = ProxyWithOldStyleIsInstance2(lambda: target)

assert wrapper.__class__ is ProxyWithOldStyleIsInstance2

assert isinstance(wrapper, ProxyWithOldStyleIsInstance2)

assert not isinstance(wrapper, objects.Target)

assert not isinstance(wrapper, objects.TargetBaseClass)

def test_class_of_instance(lop):

# Test preservation of instance __class__ attribute.

target = objects.Target()

wrapper = lop.Proxy(lambda: target)

assert wrapper.__class__ is target.__class__

assert isinstance(wrapper, objects.Target)

assert isinstance(wrapper, objects.TargetBaseClass)

@graalpyxfail

def test_class_of_function(lop):

# Test preservation of function __class__ attribute.

target = objects.target

wrapper = lop.Proxy(lambda: target)

assert wrapper.__class__ is target.__class__

assert isinstance(wrapper, type(target))

def test_dir_of_class(lop):

# Test preservation of class __dir__ attribute.

target = objects.Target

wrapper = lop.Proxy(lambda: target)

assert dir(wrapper) == dir(target)

@pytest.mark.xfail_simple

def test_vars_of_class(lop):

# Test preservation of class __dir__ attribute.

target = objects.Target

wrapper = lop.Proxy(lambda: target)

assert vars(wrapper) == vars(target)

def test_dir_of_instance(lop):

# Test preservation of instance __dir__ attribute.

target = objects.Target()

wrapper = lop.Proxy(lambda: target)

assert dir(wrapper) == dir(target)

@pytest.mark.xfail_simple

def test_vars_of_instance(lop):

# Test preservation of instance __dir__ attribute.

target = objects.Target()

wrapper = lop.Proxy(lambda: target)

assert vars(wrapper) == vars(target)

def test_dir_of_function(lop):

# Test preservation of function __dir__ attribute.

target = objects.target

wrapper = lop.Proxy(lambda: target)

assert dir(wrapper) == dir(target)

@pytest.mark.xfail_simple

def test_vars_of_function(lop):

# Test preservation of function __dir__ attribute.

target = objects.target

wrapper = lop.Proxy(lambda: target)

assert vars(wrapper) == vars(target)

def test_function_no_args(lop):

_args = ()

_kwargs = {}

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: function)

result = wrapper()

assert result == (_args, _kwargs)

def test_function_args(lop):

_args = (1, 2)

_kwargs = {}

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: function)

result = wrapper(*_args)

assert result == (_args, _kwargs)

def test_function_kwargs(lop):

_args = ()

_kwargs = {'one': 1, 'two': 2}

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: function)

result = wrapper(**_kwargs)

assert result == (_args, _kwargs)

def test_function_args_plus_kwargs(lop):

_args = (1, 2)

_kwargs = {'one': 1, 'two': 2}

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: function)

result = wrapper(*_args, **_kwargs)

assert result == (_args, _kwargs)

def test_instancemethod_no_args(lop):

_args = ()

_kwargs = {}

class Class:

def function(self, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper()

assert result == (_args, _kwargs)

def test_instancemethod_args(lop):

_args = (1, 2)

_kwargs = {}

class Class:

def function(self, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(*_args)

assert result == (_args, _kwargs)

def test_instancemethod_kwargs(lop):

_args = ()

_kwargs = {'one': 1, 'two': 2}

class Class:

def function(self, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(**_kwargs)

assert result == (_args, _kwargs)

def test_instancemethod_args_plus_kwargs(lop):

_args = (1, 2)

_kwargs = {'one': 1, 'two': 2}

class Class:

def function(self, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(*_args, **_kwargs)

assert result == (_args, _kwargs)

def test_instancemethod_via_class_no_args(lop):

_args = ()

_kwargs = {}

class Class:

def function(self, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(Class())

assert result == (_args, _kwargs)

def test_instancemethod_via_class_args(lop):

_args = (1, 2)

_kwargs = {}

class Class:

def function(self, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(Class(), *_args)

assert result == (_args, _kwargs)

def test_instancemethod_via_class_kwargs(lop):

_args = ()

_kwargs = {'one': 1, 'two': 2}

class Class:

def function(self, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(Class(), **_kwargs)

assert result == (_args, _kwargs)

def test_instancemethod_via_class_args_plus_kwargs(lop):

_args = (1, 2)

_kwargs = {'one': 1, 'two': 2}

class Class:

def function(self, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(Class(), *_args, **_kwargs)

assert result == (_args, _kwargs)

def test_classmethod_no_args(lop):

_args = ()

_kwargs = {}

class Class:

@classmethod

def function(cls, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper()

assert result == (_args, _kwargs)

def test_classmethod_args(lop):

_args = (1, 2)

_kwargs = {}

class Class:

@classmethod

def function(cls, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(*_args)

assert result == (_args, _kwargs)

def test_classmethod_kwargs(lop):

_args = ()

_kwargs = {'one': 1, 'two': 2}

class Class:

@classmethod

def function(cls, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(**_kwargs)

assert result == (_args, _kwargs)

def test_classmethod_args_plus_kwargs(lop):

_args = (1, 2)

_kwargs = {'one': 1, 'two': 2}

class Class:

@classmethod

def function(cls, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(*_args, **_kwargs)

assert result == (_args, _kwargs)

def test_classmethod_via_class_no_args(lop):

_args = ()

_kwargs = {}

class Class:

@classmethod

def function(cls, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper()

assert result == (_args, _kwargs)

def test_classmethod_via_class_args(lop):

_args = (1, 2)

_kwargs = {}

class Class:

@classmethod

def function(cls, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(*_args)

assert result == (_args, _kwargs)

def test_classmethod_via_class_kwargs(lop):

_args = ()

_kwargs = {'one': 1, 'two': 2}

class Class:

@classmethod

def function(cls, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(**_kwargs)

assert result == (_args, _kwargs)

def test_classmethod_via_class_args_plus_kwargs(lop):

_args = (1, 2)

_kwargs = {'one': 1, 'two': 2}

class Class:

@classmethod

def function(cls, *args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(*_args, **_kwargs)

assert result == (_args, _kwargs)

def test_staticmethod_no_args(lop):

_args = ()

_kwargs = {}

class Class:

@staticmethod

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper()

assert result == (_args, _kwargs)

def test_staticmethod_args(lop):

_args = (1, 2)

_kwargs = {}

class Class:

@staticmethod

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(*_args)

assert result == (_args, _kwargs)

def test_staticmethod_kwargs(lop):

_args = ()

_kwargs = {'one': 1, 'two': 2}

class Class:

@staticmethod

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(**_kwargs)

assert result == (_args, _kwargs)

def test_staticmethod_args_plus_kwargs(lop):

_args = (1, 2)

_kwargs = {'one': 1, 'two': 2}

class Class:

@staticmethod

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class().function)

result = wrapper(*_args, **_kwargs)

assert result == (_args, _kwargs)

def test_staticmethod_via_class_no_args(lop):

_args = ()

_kwargs = {}

class Class:

@staticmethod

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper()

assert result == (_args, _kwargs)

def test_staticmethod_via_class_args(lop):

_args = (1, 2)

_kwargs = {}

class Class:

@staticmethod

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(*_args)

assert result == (_args, _kwargs)

def test_staticmethod_via_class_kwargs(lop):

_args = ()

_kwargs = {'one': 1, 'two': 2}

class Class:

@staticmethod

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(**_kwargs)

assert result == (_args, _kwargs)

def test_staticmethod_via_class_args_plus_kwargs(lop):

_args = (1, 2)

_kwargs = {'one': 1, 'two': 2}

class Class:

@staticmethod

def function(*args, **kwargs):

return args, kwargs

wrapper = lop.Proxy(lambda: Class.function)

result = wrapper(*_args, **_kwargs)

assert result == (_args, _kwargs)

def test_iteration(lop):

items = [1, 2]

wrapper = lop.Proxy(lambda: items)

result = [x for x in wrapper] # noqa: C416

assert result == items

with pytest.raises(TypeError):

for _ in lop.Proxy(lambda: 1):

pass

def test_iter_builtin(lop):

iter(lop.Proxy(lambda: [1, 2]))

pytest.raises(TypeError, iter, lop.Proxy(lambda: 1))

def test_context_manager(lop):

class Class:

def __enter__(self):

return self

def __exit__(*args, **kwargs):

return

instance = Class()

wrapper = lop.Proxy(lambda: instance)

with wrapper:

pass

def test_object_hash(lop):

def function1(*args, **kwargs):

return args, kwargs

function2 = lop.Proxy(lambda: function1)

assert hash(function2) == hash(function1)

def test_mapping_key(lop):

def function1(*args, **kwargs):

return args, kwargs

function2 = lop.Proxy(lambda: function1)

table = {function1: True}

assert table.get(function2)

table = {function2: True}

assert table.get(function1)

def test_comparison(lop):

one = lop.Proxy(lambda: 1)

two = lop.Proxy(lambda: 2)

three = lop.Proxy(lambda: 3)

assert two > 1

assert two >= 1

assert two < 3

assert two <= 3

assert two != 1

assert two == 2

assert two != 3

assert 2 > one

assert 2 >= one

assert 2 < three

assert 2 <= three

assert 2 != one

assert 2 == two

assert 2 != three

assert two > one

assert two >= one

assert two < three

assert two <= three

assert two != one

assert two == two

assert two != three

def test_nonzero(lop):

true = lop.Proxy(lambda: True)

false = lop.Proxy(lambda: False)

assert true

assert not false

assert bool(true)

assert not bool(false)

assert not false

assert not not true

def test_int(lop):

one = lop.Proxy(lambda: 1)

assert int(one) == 1

def test_float(lop):

one = lop.Proxy(lambda: 1)

assert float(one) == 1.0

def test_add(lop):

one = lop.Proxy(lambda: 1)

two = lop.Proxy(lambda: 2)

assert one + two == 1 + 2

assert 1 + two == 1 + 2

assert one + 2 == 1 + 2

def test_sub(lop):

one = lop.Proxy(lambda: 1)

two = lop.Proxy(lambda: 2)

assert one - two == 1 - 2

assert 1 - two == 1 - 2

assert one - 2 == 1 - 2

def test_mul(lop):

two = lop.Proxy(lambda: 2)

three = lop.Proxy(lambda: 3)

assert two * three == 2 * 3

assert 2 * three == 2 * 3

assert two * 3 == 2 * 3

def test_matmul(lop):

class MatmulClass:

def __init__(self, value):

self.value = value

def __matmul__(self, other):

return self.value * other.value

def __rmatmul__(self, other):

return other + self.value

one = MatmulClass(123)

two = MatmulClass(234)

assert one @ two == 28782

one = lop.Proxy(lambda: MatmulClass(123))

two = lop.Proxy(lambda: MatmulClass(234))

assert one @ two == 28782

one = lop.Proxy(lambda: MatmulClass(123))

two = MatmulClass(234)

assert one @ two == 28782

one = 123

two = lop.Proxy(lambda: MatmulClass(234))

assert one @ two == 357

one = lop.Proxy(lambda: 123)

two = lop.Proxy(lambda: MatmulClass(234))

assert one @ two == 357

def test_div(lop):

# On Python 2 this will pick up div and on Python

# 3 it will pick up truediv.

two = lop.Proxy(lambda: 2)

three = lop.Proxy(lambda: 3)

assert two / three == 2 / 3

assert 2 / three == 2 / 3

assert two / 3 == 2 / 3

def test_divdiv(lop):

two = lop.Proxy(lambda: 2)

three = lop.Proxy(lambda: 3)

assert three // two == 3 // 2

assert 3 // two == 3 // 2

assert three // 2 == 3 // 2

def test_mod(lop):

two = lop.Proxy(lambda: 2)

three = lop.Proxy(lambda: 3)

assert three % two == 3 % 2

assert 3 % two == 3 % 2

assert three % 2 == 3 % 2

def test_divmod(lop):

two = lop.Proxy(lambda: 2)

three = lop.Proxy(lambda: 3)

assert divmod(three, two), divmod(3 == 2)

assert divmod(3, two), divmod(3 == 2)

assert divmod(three, 2), divmod(3 == 2)

def test_pow(lop):

two = lop.Proxy(lambda: 2)

three = lop.Proxy(lambda: 3)

assert three**two == pow(3, 2)

assert 3**two == pow(3, 2)

assert pow(3, two) == pow(3, 2)

assert three**2 == pow(3, 2)

assert pow(three, two) == pow(3, 2)

assert pow(3, two) == pow(3, 2)