def do_combination_t(test, input, expected_items, expected_combinations):
assert isinstance(expected_items, odict)
_parser = argparse.ArgumentParser()
c4args.add_select(_parser)
c4args.add_bundle_flags(_parser)
args = _parser.parse_args(input)
# util.logcmd(input, "\n", args)
for i in ('systems', 'architectures', 'compilers', 'build_types',
'variants'):
expected = expected_items[i]
expected = [e.split(':')[0] for e in expected]
actual = getattr(args, i)
actual = [a.split(':')[0] for a in actual]
# print(i, "actual=", actual)
# print(i, "expected=", expected)
# with test.subTest(msg="expected count of "+i, input=input):
# test.assertEqual(len(actual), len(expected))
with test.subTest(msg="expected list of " + i, input=input):
test.assertEqual(actual, expected)
# expected combinations (constructed with their types)
expected_combinations = [(cmany.System(s), cmany.Architecture(a),
cmany.Compiler(c), cmany.BuildType(t),
cmany.Variant(v))
for s, a, c, t, v in expected_combinations]
# actual combinations
s, a, c, t, v = cmany.Project.get_build_items(**vars(args))
cr = []
if hasattr(args, 'combination_rules'):
cr = args.combination_rules
cr = CombinationRules(cr)
actual_combinations = cr.valid_combinations(s, a, c, t, v)
# print("\n")
# for i, (e, a) in enumerate(zip(expected_combinations, actual_combinations)):
# print("expected[{}]".format(i), e, "actual[{}]".format(i), a)
with test.subTest(msg="expected count of combinations", input=input):
test.assertEqual(len(expected_combinations), len(actual_combinations))
for exp, act in zip(expected_combinations, actual_combinations):
#print("exp x act:", exp, act)
with test.subTest(msg="combination architecture", input=input):
test.assertEqual(act[0].name, exp[0].name)
with test.subTest(msg="combination system", input=input):
test.assertEqual(act[1].name, exp[1].name)
with test.subTest(msg="combination compiler", input=input):
test.assertEqual(act[2].name, exp[2].name)
with test.subTest(msg="combination build type", input=input):
test.assertEqual(act[3].name, exp[3].name)
with test.subTest(msg="combination variant", input=input):
test.assertEqual(act[4].name, exp[4].name)
def tp(self, input, which_var, expected_name, **expected_props):
parser = argparse.ArgumentParser()
c4args.add_select(parser)
args = parser.parse_args(input)
vars = variant.Variant.create_variants(args.variants)
self.assertTrue(which_var < len(vars))
var = vars[which_var]
self.assertEqual(var.name, expected_name)
for k, refval in expected_props.items():
result = getattr(var.flags, k)
with self.subTest(input=input, which_var=which_var, desc='variant properties', prop=k):
self.assertEqual(result, refval, msg='property: ' + k)
def t(self, input, expected):
parser = argparse.ArgumentParser()
c4args.add_select(parser)
args = parser.parse_args(input)
with self.subTest(input=input, desc='argument parsing'):
self.assertEqual(args.variants, expected, msg=input)
def add_args(self, parser):
super().add_args(parser)
c4args.add_select(parser)