def test_replace():
unsafe = "abABabAB"
unsafe_old = "AB"
unsafe_new = "ab"
unsafe_old2 = "cd"
safe = safe_string(unsafe,
trusted=frozenbitarray([
True, True, False, False, True, True, False, False
]))
old_str = safe_string(unsafe_old, frozenbitarray([False] * 2))
old_str2 = safe_string(unsafe_old2, frozenbitarray([False] * 2))
new_str = safe_string(unsafe_new, trusted=frozenbitarray([True] * 2))
assert unsafe.replace(unsafe_old,
unsafe_new) == safe.replace(old_str, new_str)
assert safe.replace(old_str,
new_str)._trusted == frozenbitarray([True] * 8)
assert unsafe.replace(unsafe_old, unsafe_new,
1) == safe.replace(old_str, new_str, 1)
assert safe.replace(old_str, new_str, 1)._trusted == frozenbitarray(
[True, True, True, True, True, True, False, False])
assert unsafe.replace(unsafe_old, unsafe_new,
10) == safe.replace(old_str, new_str, 10)
assert safe.replace(old_str, new_str,
10)._trusted == frozenbitarray([True] * 8)
assert unsafe.replace(unsafe_old2,
unsafe_new) == safe.replace(old_str2, new_str)
assert safe.replace(old_str2, new_str)._trusted == safe._trusted
def test_count():
unsafe = "abABabAB"
unsafe_old1 = "AB"
unsafe_old2 = "cd"
safe = safe_string(unsafe,
trusted=frozenbitarray([
True, True, False, False, True, True, False, False
]))
old_str1 = safe_string(unsafe_old1, frozenbitarray([False] * 2))
old_str2 = safe_string(unsafe_old2, frozenbitarray([False] * 2))
assert safe.count(old_str1) == unsafe.count(unsafe_old1)
assert safe.count(old_str2) == unsafe.count(unsafe_old2)
def test_repr_same_length():
examples = [
"abc",
"\\",
"\n",
b"Ni\xc3\xb10".decode("utf-8"),
string.printable,
"\x0c",
"\x1c",
"\x2c",
"\xff",
"\xf8",
"\x7f\x8f\x9f\xff",
"\f",
"\t",
" ",
"",
]
for unsafe in examples:
# safe = gen_random_safe_from_unsafe(unsafe)
safe = safe_string(
unsafe,
frozenbitarray([True, False] * (len(unsafe) // 2) + [True] *
(len(unsafe) % 2)))
safe_repr = repr(safe)
assert len(safe_repr) == len(repr(unsafe))
if len(safe_repr) != len(safe_repr._trusted):
safe._debug_repr()
safe_repr._debug_repr()
assert False
def test_substrings_are_returned_correctly():
length = 100
string = gen_random_string(length)
trusted = gen_random_trusted(length)
safe = safe_string(string, trusted=trusted)
for i in range(-(length + 5), (length + 5)):
for j in range(-(length + 5), (length + 5)):
sub = safe[i:j]
assert sub == string[i:j]
assert sub._trusted == trusted[i:j]
def test_can_create_new_safe_strings():
for length in range(100):
unsafe = gen_random_string(length)
trusted = gen_random_trusted(length)
safe_string(unsafe, trusted)
def gen_random_safe_from_unsafe(string):
return safe_string(string, trusted=gen_random_trusted(len(string)))
def gen_random_safe_string(length):
return safe_string(gen_random_string(length),
trusted=gen_random_trusted(length))
from types import SimpleNamespace
person = SimpleNamespace()
person.name = "foo"
assert resolve_lookups([{"p": person}], "[0][p].name") == "foo"
person = SimpleNamespace()
person.name = SimpleNamespace()
person.name.first = "foo"
assert resolve_lookups([{"p": person}], "[0][p].name.first") == "foo"
person = SimpleNamespace()
person.name = ["foo", "bar"]
items = SimpleNamespace()
items.first = {"p": person}
assert resolve_lookups(items, ".first[p].name[0]") == "foo"
def test_field_parser():
parser = field_parser([10, 20, 30, 40], {"name": "foo"})
assert parser("{name[0]}") == ("f", None, "")
assert parser("{}") == (10, None, "")
assert parser("{name[0]:[1]}") == ("f", None, "[1]")
if __name__ == '__main__':
fmt_s = "{name[0]!a} {!s} {!r}"
fmt = safe_string(fmt_s, trusted=frozenbitarray([True] * len(fmt_s)))
nino = b"Ni\xc3\xb10".decode("utf-8")
fmt.format(10, 18, name=[nino])._debug_repr()
