def test_cached_hash_wrapper():
class TestClass(object):
pass
w1a = qcore.CachedHashWrapper(TestClass())
w1b = qcore.CachedHashWrapper(w1a())
w2a = qcore.CachedHashWrapper(TestClass())
print("w1a", w1a)
print("w1b", w1b)
print("w2a", w2a)
assert_is(w1a.value(), w1a())
assert_is(w1a(), w1b())
assert_is_not(w1a(), w2a())
assert_eq(w1a, w1b)
assert_ne(w1a, w2a)
assert_ne(w1b, w2a)
assert_eq(w1a, w1b())
assert_ne(w1a, w2a())
assert_ne(w1b, w2a())
assert_eq(hash(w1a), hash(w1b))
assert_ne(hash(w1a), hash(w2a))
assert_ne(hash(w1b), hash(w2a))
def test_common():
o = qcore.MarkerObject("o @ qcore.test_examples")
assert_is_not(o, qcore.miss)
o = qcore.dict_to_object({"a": 1, "b": 2})
assert_eq(o.a, 1) # Zero overhead!
assert_eq(o.b, 2) # Zero overhead!
def test_not_found(self):
node = ast.parse("a.b(c)")
random_node = ast.Name(id="d")
new_node = ReplaceNodeTransformer(random_node,
node.body[0].value.func).visit(node)
assert_is_not(new_node, node)
assert_code_equal("a.b(c)\n", decompile(new_node))
def test_unbound_method_value() -> None:
val = value.UnboundMethodValue("get_prop_with_get",
value.TypedValue(tests.PropertyObject))
assert_eq("<method get_prop_with_get on pyanalyze.tests.PropertyObject>",
str(val))
assert_eq("get_prop_with_get", val.attr_name)
assert_eq(TypedValue(tests.PropertyObject), val.typ)
assert_is(None, val.secondary_attr_name)
assert_eq(tests.PropertyObject.get_prop_with_get, val.get_method())
assert val.is_type(object)
assert not val.is_type(str)
val = value.UnboundMethodValue(
"get_prop_with_get",
value.TypedValue(tests.PropertyObject),
secondary_attr_name="asynq",
)
assert_eq(
"<method get_prop_with_get.asynq on pyanalyze.tests.PropertyObject>",
str(val))
assert_eq("get_prop_with_get", val.attr_name)
assert_eq(TypedValue(tests.PropertyObject), val.typ)
assert_eq("asynq", val.secondary_attr_name)
method = val.get_method()
assert_is_not(None, method)
assert_in(method.__name__, tests.ASYNQ_METHOD_NAMES)
assert_eq(tests.PropertyObject.get_prop_with_get, method.__self__)
assert val.is_type(object)
assert not val.is_type(str)
def test_found(self):
node = ast.parse("a.b(c)")
replacement_node = ast.Name(id="d")
new_node = ReplaceNodeTransformer(node.body[0].value.func,
replacement_node).visit(node)
# ensure it doesn't mutate the existing node in place
assert_is_not(new_node, node)
assert_code_equal("d(c)\n", decompile(new_node))
def capybara(cond):
if cond:
x = True
else:
x = False
assert_is_value(
x, MultiValuedValue([KnownValue(True),
KnownValue(False)]))
assert_is_not(x, True)
assert_is_value(x, KnownValue(False))
def test_asynq_traceback_gets_glued_at_each_task_level():
# tests that exceptions are producting the right tracebacks
traceback_to_verify = None
try:
async_function_whose_child_async_task_will_throw_an_error()
except ValueError:
traceback_to_verify = sys.exc_info()[2]
assert_is_not(None, traceback_to_verify)
traceback_printed = '\n'.join(traceback.format_tb(traceback_to_verify))
assert_in(non_async_function_that_raises_an_error.__name__, traceback_printed)
assert_in(async_function_that_raises_an_error.__name__, traceback_printed)
assert_in(async_function_whose_child_async_task_will_throw_an_error.__name__, traceback_printed)
def paca(cond):
if cond:
x = True
y = True
else:
x = False
y = False
assert_is_value(x, MultiValuedValue([KnownValue(True), KnownValue(False)]))
assert_is_value(y, MultiValuedValue([KnownValue(True), KnownValue(False)]))
assert_is_not(x, True)
assert_is_not(True, y)
assert_is_value(x, KnownValue(False))
assert_is_value(y, KnownValue(False))
def test_variable_name_value():
uid_val = value.VariableNameValue(["uid", "viewer"])
varname_map = {
"uid": uid_val,
"viewer": uid_val,
"actor_id": value.VariableNameValue(["actor_id"]),
}
assert_is(None,
value.VariableNameValue.from_varname("capybaras", varname_map))
val = value.VariableNameValue.from_varname("uid", varname_map)
assert_is(val, value.VariableNameValue.from_varname("viewer", varname_map))
assert_is(val,
value.VariableNameValue.from_varname("old_uid", varname_map))
assert_is_not(
val, value.VariableNameValue.from_varname("actor_id", varname_map))
def test_assert_is_not():
assert_is_not(None, 1)
assert_is_not(int, type("s"))
# Assign to val to make the assertion look more prototypical.
val = None
with AssertRaises(AssertionError):
assert_is_not(None, val)
with AssertRaises(AssertionError):
assert_is_not(int, type(1))
def test_variable_name_value() -> None:
uid_val = value.VariableNameValue(["uid", "viewer"])
varname_map = {
"uid": uid_val,
"viewer": uid_val,
"actor_id": value.VariableNameValue(["actor_id"]),
}
assert_is(None,
value.VariableNameValue.from_varname("capybaras", varname_map))
val = value.VariableNameValue.from_varname("uid", varname_map)
assert_is_not(None, val)
assert_is(val, value.VariableNameValue.from_varname("viewer", varname_map))
assert_is(val,
value.VariableNameValue.from_varname("old_uid", varname_map))
assert_is_not(
val, value.VariableNameValue.from_varname("actor_id", varname_map))
assert_can_assign(TypedValue(int), val)
assert_can_assign(KnownValue(1), val)
assert_can_assign(val, TypedValue(int))
assert_can_assign(val, KnownValue(1))
