from __future__ import print_function
from __future__ import unicode_literals
import CppHeaderParser
import copy
import sys
expected = CppHeaderParser.CppHeader(sys.argv[1], argType="string")
actual = CppHeaderParser.CppHeader(sys.argv[2], argType="string")
def check(expr, msg, *args):
if not expr:
print(msg.format(*args))
sys.exit(1)
check(expected.defines == actual.defines, "incorrect include-guard, or too many #defines")
typedefs_not_found = copy.deepcopy(expected.typedefs)
for (new_type, old_type) in actual.typedefs.items():
check(
new_type in expected.typedefs,
"`typedef {} {}` was not expected", old_type, new_type,
)
check(
actual.typedefs[new_type] == expected.typedefs[new_type],
"incorrect typedef:\nexpected: {!r}\nfound: {!r}",
expected.typedefs[new_type], actual.typedefs[new_type],
)
typedefs_not_found.pop(new_type)
if len(typedefs_not_found) > 0:
print("the following typedefs were expected but were not found:")
for (new_type, old_type) in typedefs_not_found.items():
print("typedef {} {};".format(old_type, new_type))
sys.exit(1)
enums_not_found = map(lambda e: { "name": e["name"], "values": e["values"] }, expected.enums)
for enum in actual.enums:
check(
enum['typedef'] is True,
"line {}: enum {!r} was not `typedef`ed", enum['line_number'], enum['name'],
)
expected_enum = filter(lambda e: e['name'] == enum['name'], expected.enums)
if len(expected_enum) > 1:
raise Exception("internal error: multiple enums with name {!r} in 'correct' header file: {!r}".format(enum["name"], sys.argv[1]))
check(
len(expected_enum) > 0,
"line {}: enum {!r} was not expected", enum["line_number"], enum["name"],
)
expected_enum = expected_enum[0]
enums_not_found.remove({ "name": expected_enum["name"], "values": expected_enum["values"] })
check(
expected_enum["values"] == enum["values"],
"line {}: enum {!r} has incorrect values:\nexpected: {!r}\nfound: {!r}",
enum["line_number"], enum["name"], expected_enum["values"], enum["values"],
)
if len(enums_not_found) > 0:
print("the following enums were expected but were not found:")
for enum in enums_not_found:
print("{!r}: {!r}".format(enum["name"], enum["values"]))
sys.exit(1)
funcs_not_found = map(lambda f: f["debug"], expected.functions)
for func in actual.functions:
check(
any(map(lambda f: f["debug"] == func["debug"], expected.functions)),
"line {}: function not expected: {!r}", func["line_number"], func["debug"],
)
funcs_not_found.remove(func["debug"])
if len(funcs_not_found) > 0:
print("the following functions were expected but were not found:")
for func in funcs_not_found:
print(func)
sys.exit(1)
structs_not_found = copy.deepcopy(expected.classes)
for (key, struct) in actual.classes.items():
expected_struct = filter(lambda s: s["name"] == struct["name"], expected.classes.values())
if len(expected_struct) > 1:
raise Exception("internal error: multiple structs with name {!r} in 'correct' header file: {!r}".format(struct["name"], sys.argv[1]))
check(
len(expected_struct) > 0,
"line {}: struct {!r} was not expected", struct["line_number"], struct["name"],
)
expected_struct = expected_struct[0]
values = map(lambda s: { "name": s["name"], "type": s["type"] }, struct["properties"]["public"])
expected_values = map(lambda s: { "name": s["name"], "type": s["type"] }, expected_struct["properties"]["public"])
check(
values == expected_values,
"line {}: struct {!r} has incorrect members:\nexpected: {!r}\nfound: {!r}\n",
struct["line_number"], struct["name"], values, expected_values,
)
structs_not_found.pop(key)
if len(structs_not_found) > 0:
print("the following structs were expected but not found:")
for struct in structs_not_found.values():
print("typedef struct {} {{".format(struct["name"]))
for member in struct["properties"]["public"]:
print("\t{} {};".format(member["type"], member["name"]))
print("}} {};".format(struct["name"]))
sys.exit(1)