297 lines
9.3 KiB
Python
297 lines
9.3 KiB
Python
import sys
|
|
import importlib
|
|
import subprocess
|
|
import ctypes
|
|
import random
|
|
import traceback
|
|
import textwrap
|
|
import json
|
|
import os
|
|
import shutil
|
|
try:
|
|
from tqdm import tqdm, trange
|
|
except ImportError:
|
|
print("`tqdm` not found. there will be no progress bars")
|
|
def tqdm(x):
|
|
return x
|
|
trange = range
|
|
|
|
|
|
filename = sys.argv[1]
|
|
|
|
if filename.endswith(".py"):
|
|
print("importing as Python...")
|
|
module = importlib.import_module(filename.removesuffix(".py"))
|
|
print("done.")
|
|
try:
|
|
entry = module.entry
|
|
except AttributeError:
|
|
print("module is missing entrypoint `entry`. aborting.")
|
|
sys.exit(1)
|
|
elif filename.endswith(".c"):
|
|
print("compiling as C with `gcc`...")
|
|
obj = "./" + filename.removesuffix(".c") + ".so"
|
|
rc = subprocess.call(["gcc", "-shared", "-fPIC", *sys.argv[2:], filename, "-o", obj])
|
|
if rc != 0:
|
|
print("compilation failed. aborting.")
|
|
sys.exit(rc)
|
|
lib = ctypes.CDLL(obj)
|
|
try:
|
|
entry = lambda s: lib.entry(s.encode())
|
|
except AttributeError:
|
|
print("library is missing entrypoint `entry`. aborting.")
|
|
sys.exit(1)
|
|
elif filename.endswith(".rs"):
|
|
print("compiling as Rust...")
|
|
os.makedirs("./entry-rs/src", exist_ok=True)
|
|
with open("./entry-rs/Cargo.toml", "w") as f:
|
|
f.write("""
|
|
[package]
|
|
name = "entry-rs"
|
|
version = "0.1.0"
|
|
edition = "2021"
|
|
|
|
[lib]
|
|
name = "entry_rs"
|
|
crate-type = ["cdylib"]
|
|
|
|
[dependencies.pyo3]
|
|
version = "0.14.5"
|
|
features = ["extension-module"]
|
|
""")
|
|
with open("./entry-rs/src/lib.rs", "w") as f:
|
|
f.write("""
|
|
use pyo3::prelude::*;
|
|
|
|
mod entry_impl;
|
|
use entry_impl::entry;
|
|
|
|
#[pyfunction]
|
|
fn wrapped_entry(s: &str) -> PyResult<bool> {
|
|
Ok(entry(s))
|
|
}
|
|
|
|
#[pymodule]
|
|
fn entry_rs(_py: Python, m: &PyModule) -> PyResult<()> {
|
|
m.add_function(wrap_pyfunction!(wrapped_entry, m)?)?;
|
|
Ok(())
|
|
}
|
|
""")
|
|
shutil.copyfile(filename, "./entry-rs/src/entry_impl.rs")
|
|
os.chdir("entry-rs")
|
|
rc = subprocess.call(["cargo", "build", "--release"])
|
|
os.chdir("..")
|
|
if rc != 0:
|
|
print("compilation failed. aborting.")
|
|
sys.exit(1)
|
|
sys.path.append("./entry-rs/target/release")
|
|
os.rename("./entry-rs/target/release/libentry_rs.so", "./entry-rs/target/release/entry_rs.so")
|
|
module = importlib.import_module("entry_rs")
|
|
entry = module.wrapped_entry
|
|
else:
|
|
print("unrecognized file extension")
|
|
sys.exit(1)
|
|
|
|
|
|
tests = [
|
|
("zero", "0", True),
|
|
("leadingws", "\n\t 0", True),
|
|
("trailingws", "0\n\t ", True),
|
|
("one", "1", True),
|
|
("negativezero", "-0", True),
|
|
("negativeone", "-1", True),
|
|
("wsisbadhere", "- 1", False),
|
|
("multidigit", "100", True),
|
|
("leadingzero", "01", False),
|
|
("noplus", "+1", False),
|
|
("decimal", "1.0", True),
|
|
("leadingdot", ".0", False),
|
|
("trailingdot", "0.", False),
|
|
("bigdecimal", "13847432.35809092", True),
|
|
("scientific", "1e2", True),
|
|
("bigscientific", "-2376420.0033533e533", True),
|
|
("capitalscientific", "2E3", True),
|
|
("scientificminus", "2e-3", True),
|
|
("scientificplusisokay", "2E+3", True),
|
|
("nowshere", "2 e + 3", False),
|
|
("integerexponent", "2e3.0", False),
|
|
("emptystring", r'""', True),
|
|
("notemptystring", r'"not empty"', True),
|
|
("escapes", r'"\n\t\r\f\b\/"', True),
|
|
("unicodeescape", r'"\uaA0b"', True),
|
|
("moreescapes", r'"\\ \" "', True),
|
|
("evilescape", r'"\"', False),
|
|
("manybackslashes", r'"\\\\\\\\"', True),
|
|
("evilmanybackslashes", r'"\\\\\\\\\"', False),
|
|
("invalidescape", r'"\j"', False),
|
|
("invalidunicodeescape", r'"\u000j"', False),
|
|
("bigstring", r'"greetings people. this is a big string. \\[}[{]}}\"&*%4783.02 I am trying to break your code. am I doing a good job?\nplease say I am\\\\"', True),
|
|
("emptyarray", "[]", True),
|
|
("lessemptyarray", "[0]", True),
|
|
("evenlessemptyarray", "[0, 1]", True),
|
|
("heterogenousarray", '[0, 2.0, "string"]', True),
|
|
("unclosedarray", "[0", False),
|
|
("trailingcomma", "[0,]", False),
|
|
("leadingcomma", "[,0]", False),
|
|
("leadingcommaobj", '{,"bee":-4}', False),
|
|
("gap", "[0,,1]", False),
|
|
("nesting", "[[], [1, [2, []], [3, 4]]]", True),
|
|
("hugenest", "[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]", True),
|
|
("emptyobject", "{}", True),
|
|
("singletonobject", r'{"key": "value"}', True),
|
|
("imaginebeinghetero", r'{"key": "value", "otherkey": 1}', True),
|
|
("keysarestrings", "{0: 0}", False),
|
|
("dupesareokay", r'{"key": 0, "key": 1}', True),
|
|
("stillnotrailingcomma", r'{"key": "value",}', False),
|
|
("mixing", r'[0, {"O.O": [{"object in a list in an object in a list\nwhat will it do": "it will do this"}]}]', True),
|
|
("whitespacesilliness", '[ \t 0 , { "whitespace4all" : \n {"woah" :[\n [ \n ] ,0 ]} \t}]', True),
|
|
("true", "true", True), # hehe
|
|
("false", "false", True),
|
|
("null", "null", True),
|
|
("nototherstuff", "asdf", False),
|
|
("alltogethernow", r"""
|
|
{
|
|
"this": "a JSON value",
|
|
"people": [
|
|
{
|
|
"name": "christina",
|
|
"value": 1e100
|
|
},
|
|
{
|
|
"name": "everyone else probably\nidk",
|
|
"value": 0.0e0
|
|
}
|
|
],
|
|
"peoplecoolerthanchristina": {
|
|
"value": null,
|
|
"ready": false,
|
|
"status": "still processing"
|
|
}
|
|
}
|
|
""", True),
|
|
("noextradata", '["stuff"]extra stuff', False),
|
|
]
|
|
|
|
print("beginning testing suite")
|
|
failures = 0
|
|
|
|
for test_name, value, result in tqdm(tests):
|
|
print(f"`{test_name}`... ", end="")
|
|
try:
|
|
r = entry(value)
|
|
except BaseException:
|
|
print("error")
|
|
traceback.print_exc()
|
|
failures += 1
|
|
continue
|
|
if bool(r) == result:
|
|
print("ok")
|
|
else:
|
|
failures += 1
|
|
print("failed")
|
|
print(f"for test `{test_name}`:")
|
|
print(textwrap.indent(value, " "*2))
|
|
print(f"entry returned {r} when {result} was expected\n")
|
|
if not failures:
|
|
print("test suite finished, all ok")
|
|
else:
|
|
print(f"test suite finished. {failures} tests failed\n\n")
|
|
print("skipping randomized testing because your program is clearly broken and the output from those isn't very helpful for finding bugs")
|
|
sys.exit(2)
|
|
|
|
|
|
l = [r'\"', r'\\', r'\b', r'\f', r'\n', r'\r', r'\t', rf"\u{random.randint(0x0000, 0xFFFF):04{random.choice('xX')}}", *map(chr, range(ord(" "), ord("}")+1))]
|
|
l.remove("\\")
|
|
l.remove('"')
|
|
|
|
def gen_random_string():
|
|
s = '"'
|
|
for _ in range(random.randint(0, 8)):
|
|
s += random.choice(l)
|
|
s += '"'
|
|
return wsify(s)
|
|
|
|
def wsify(s):
|
|
return s + random.choice(" \t\n")*random.randint(0, 2)
|
|
|
|
def gen_random_json(n=1):
|
|
if n >= 12:
|
|
t = random.choice(["sentinel", "number", "string"])
|
|
else:
|
|
t = random.choice(["sentinel", "number", "array", "object", "string", "string", "number", "sentinel"])
|
|
if t == "sentinel":
|
|
return wsify(random.choice(["true", "false", "null"]))
|
|
elif t == "string":
|
|
return gen_random_string()
|
|
elif t == "array":
|
|
return wsify("[") + wsify(",").join(gen_random_json(n+1) for _ in range(5)) + wsify("]")
|
|
elif t == "object":
|
|
return wsify("{") + wsify(",").join(gen_random_string() + ":" + gen_random_json(n+1) for _ in range(5)) + wsify("}")
|
|
elif t == "number":
|
|
nt = random.choice(["int", "decimal", "sci"])
|
|
if nt == "int":
|
|
r = str(random.randint(0, 1000000000))
|
|
elif nt == "decimal":
|
|
r = str(random.uniform(0, 1000000000))
|
|
elif nt == "sci":
|
|
e = random.choice(["e", "E"])
|
|
p = random.choice(["+", "-", ""])
|
|
r = f"{random.uniform(0, 1000000000)}{e}{p}{random.randint(0, 1000000000)}"
|
|
else:
|
|
assert False
|
|
return "-"*random.randint(0, 1) + r
|
|
else:
|
|
assert False
|
|
|
|
|
|
print("beginning randomized testing.")
|
|
random_failures = 0
|
|
for _ in trange(100):
|
|
j = gen_random_json()
|
|
tr = True
|
|
if random.randint(0, 1):
|
|
j = list(j)
|
|
for _ in range(20):
|
|
t = random.choice(["insert", "remove", "replace", "replace", "replace"])
|
|
if not j and t in ("remove", "replace"):
|
|
continue
|
|
idx = random.randrange(0, len(j)+(t == "insert"))
|
|
c = random.choice(["\n", "\t", " ", *map(chr, range(ord(" "), ord("}")+1))])
|
|
if t == "replace":
|
|
j[idx] = c
|
|
elif t == "insert":
|
|
j.insert(idx, c)
|
|
elif t == "remove":
|
|
j.pop(idx)
|
|
j = "".join(j)
|
|
try:
|
|
json.loads(j)
|
|
except json.JSONDecodeError:
|
|
tr = False
|
|
try:
|
|
r = entry(j)
|
|
except BaseException:
|
|
print("error")
|
|
traceback.print_exc()
|
|
random_failures += 1
|
|
continue
|
|
if bool(r) != tr:
|
|
print("randomized test case failed:")
|
|
print(textwrap.indent(j, " "*2))
|
|
print(f"entry returned {r} when {tr} was expected\n")
|
|
random_failures += 1
|
|
|
|
if not random_failures:
|
|
print("randomized testing finished. all ok\n\n")
|
|
else:
|
|
print(f"randomized testing finished with {random_failures} failures\n\n")
|
|
|
|
|
|
print("overall report:")
|
|
overall = failures + random_failures
|
|
if not overall:
|
|
print("no failures detected. all seems well!")
|
|
else:
|
|
print(f"{overall} failures detected overall. you have some bugs to fix")
|
|
sys.exit(2)
|