def test_map_existing_alias(self):
text = "register q[5]; map a q; map b a"
exp_result = {
Identifier("a"): TreeManipulators.make_identifier("q"),
Identifier("b"): TreeManipulators.make_identifier("a"),
}
self.run_test(text, exp_result)
def test_extract_macro(self):
text = "macro foo a { g a }"
parser = make_lark_parser()
exp_result = {
Identifier.parse("foo"): MacroRecord(
[Identifier.parse("a")],
make_lark_parser(start="sequential_gate_block").parse("{ g a }"),
)
}
act_result = extract_macro(parser.parse(text))
self.assertEqual(exp_result, act_result)
def test_multiple_registers(self):
text = "register q[3]; register r[2]"
exp_result = {
Identifier.parse("q"):
TreeManipulators.make_let_or_integer(
TreeManipulators.make_integer(3)),
Identifier.parse("r"):
TreeManipulators.make_let_or_integer(
TreeManipulators.make_integer(2)),
}
self.run_test(text, exp_result)
def test_track_macro(self):
text = "g0; macro m0 a b c {g1}"
exp_result = {
Identifier.parse("g0"): None,
Identifier.parse("g1"): Identifier.parse("m0"),
}
parser = make_lark_parser()
tree = parser.parse(text)
visitor = MacroTaggerVisitor()
visitor.visit(tree)
act_result = visitor.context_by_gate
self.assertEqual(exp_result, act_result)
def test_dont_replace_macro_argument(self):
let_dict = {Identifier.parse("a"): 3.14}
parser = make_lark_parser(start="macro_definition")
text = "macro foo a { g a }"
exp_tree = parser.parse(text)
act_tree = resolve_let(exp_tree, let_dict)
self.assertEqual(exp_tree, act_tree)
def test_usepulses(self):
"""Test getting information from the usepulses statement."""
text = "from foo.bar usepulses *"
exp_result = {Identifier.parse("foo.bar"): all}
iface = Interface(text, allow_no_usepulses=True)
act_result = iface.usepulses
self.assertEqual(exp_result, act_result)
def test_single_register(self):
text = "register q[3]"
exp_result = {
Identifier.parse("q"):
TreeManipulators.make_let_or_integer(
TreeManipulators.make_integer(3))
}
self.run_test(text, exp_result)
def test_replace_array_index(self):
let_dict = {Identifier.parse("a"): 1}
parser = make_lark_parser(start="gate_statement")
text = "g arr[a]"
exp_text = "g arr[1]"
exp_tree = parser.parse(exp_text)
act_tree = resolve_let(parser.parse(text), let_dict)
self.assertEqual(exp_tree, act_tree)
def test_let_constant_as_size(self):
text = "let a 5; register q[a]"
exp_result = {
Identifier.parse("q"):
TreeManipulators.make_let_or_integer(
TreeManipulators.make_let_identifier(
TreeManipulators.make_qualified_identifier("a")))
}
self.run_test(text, exp_result)
def test_map_single_index(self):
text = "register q[5]; map a q[1]"
exp_result = {
Identifier("a"):
TreeManipulators.make_array_element(
TreeManipulators.make_identifier("q"),
TreeManipulators.make_integer(1))
}
self.run_test(text, exp_result)
def test_return_usepulses(self):
text = "from MyPulses.MyClass usepulses *"
exp_value = {
"usepulses": {
Identifier.parse("MyPulses.MyClass"): all,
}
}
_, act_value = parse_jaqal_string(text,
return_usepulses=True,
autoload_pulses=False)
self.assertEqual(act_value, exp_value)
def test_map_range(self):
text = "register q[5]; map a q[1:4:2]"
exp_result = {
Identifier("a"):
TreeManipulators.make_array_slice(
TreeManipulators.make_identifier("q"),
slice(
TreeManipulators.make_integer(1),
TreeManipulators.make_integer(4),
TreeManipulators.make_integer(2),
),
)
}
self.run_test(text, exp_result)
def test_combine_dicts_extra_keys(self):
"""Test for failure when combining a dictionary that is not fully represented in the let values."""
main_dict = {Identifier.parse("foo"): 1, Identifier.parse("bar"): 2}
addl_dict = {Identifier.parse("foo"): 42, Identifier.parse("extra"): 666}
with self.assertRaises(Exception):
combine_let_dicts(main_dict, addl_dict)
def test_combine_dicts(self):
main_dict = {Identifier.parse("foo"): 1, Identifier.parse("bar"): 2}
addl_dict = {Identifier.parse("foo"): 42}
comb_dict = combine_let_dicts(main_dict, addl_dict)
self.assertEqual(comb_dict[Identifier.parse("foo")], 42)
self.assertEqual(comb_dict[Identifier.parse("bar")], 2)
def test_map_whole_register(self):
text = "register q[5]; map a q"
exp_result = {Identifier("a"): TreeManipulators.make_identifier("q")}
self.run_test(text, exp_result)
def test_simple_usepulses_all(self):
"""Test importing all symbols from a namespace."""
text = "from foo usepulses *"
exp_value = {Identifier.parse("foo"): all}
self.run_test(text, exp_value)
def test_qualified_usepulses_all(self):
"""Test importing all symbols from a qualified namespace."""
text = "from foo.bar usepulses *"
exp_value = {Identifier.parse("foo.bar"): all}
self.run_test(text, exp_value)
def test_extract_integer(self):
text = "let a 5"
exp_value = {Identifier("a"): 5}
self.run_test(text, exp_value)
def test_extract_negative_float(self):
text = "let a -5.5"
exp_value = {Identifier("a"): -5.5}
self.run_test(text, exp_value)
