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()