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)