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_serial_gate_block_no_statements(self):
text = "{}"
parser = make_lark_parser(start="gate_block")
tree = parser.parse(text)
exp_tree = self.make_serial_gate_block()
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def run_test(self, setup_text, gate_text, exp_result):
parser = make_lark_parser()
map_dict, register_dict = extract_map(parser.parse(setup_text))
act_tree = resolve_map(parser.parse(gate_text), map_dict,
register_dict)
act_result = self.simplify_tree(act_tree)
self.assertEqual(exp_result, act_result)
def test_gate_with_qualified_identifier(self):
text = "foo.g"
parser = make_lark_parser(start="gate_statement")
tree = parser.parse(text)
exp_tree = self.make_gate_statement("foo.g")
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def run_test(self, setup_text, text, exp_text):
parser = make_lark_parser()
macro_dict = extract_macro(parser.parse(setup_text))
tree = parser.parse(text)
act_result = self.simplify_tree(resolve_macro(tree, macro_dict))
exp_result = self.simplify_tree(parser.parse(exp_text))
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_parallel_gate_block_no_statements_with_newline(self):
text = "<\n>"
parser = make_lark_parser(start="gate_block")
tree = parser.parse(text)
exp_tree = self.make_parallel_gate_block()
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_gate_with_args(self):
"""Test a gate with arguments."""
text = "g a 1 2.0 -3"
parser = make_lark_parser(start="gate_statement")
tree = parser.parse(text)
exp_tree = self.make_gate_statement("g", "a", 1, 2.0, -3)
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_gate_no_args(self):
"""Test a gate with no arguments."""
text = "g"
parser = make_lark_parser(start="gate_statement")
tree = parser.parse(text)
exp_tree = self.make_gate_statement("g")
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_usepulses_all(self):
text = "from foo usepulses *"
parser = make_lark_parser(start="usepulses_statement")
tree = parser.parse(text)
exp_tree = self.make_usepulses_statement(self.make_from_clause("foo"),
[self.make_all_module()])
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_usepulses_as_statement(self):
text = "usepulses foo as bar"
parser = make_lark_parser(start="usepulses_statement")
tree = parser.parse(text)
exp_tree = self.make_usepulses_statement(
None, [self.make_as_clause("foo", "bar")])
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_import_from_statement(self):
text = "from foo import bar"
parser = make_lark_parser(start="import_statement")
tree = parser.parse(text)
exp_tree = self.make_import_statement(self.make_from_clause("foo"),
[self.make_as_clause("bar")])
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_parallel_gate_block_separator_newline(self):
text = "<g |\n f>"
parser = make_lark_parser(start="gate_block")
tree = parser.parse(text)
exp_tree = self.make_parallel_gate_block(self.make_gate_statement("g"),
self.make_gate_statement("f"))
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_map_simple(self):
"""Test parsing the map statement with simple identifiers"""
text = "map a b"
parser = make_lark_parser(start="map_statement")
tree = parser.parse(text)
exp_tree = self.make_map_statement("a", self.make_identifier("b"))
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_replace_loop_count(self):
let_dict = {Identifier.parse("a"): 1}
parser = make_lark_parser(start="loop_statement")
text = "loop a { g }"
exp_text = "loop 1 { g }"
exp_tree = parser.parse(exp_text)
act_tree = resolve_let(parser.parse(text), let_dict)
self.assertEqual(exp_tree, act_tree)
def test_replace_register_statement(self):
let_dict = {Identifier.parse("a"): 1}
parser = make_lark_parser(start="register_statement")
text = "register q[a]"
exp_text = "register q[1]"
exp_tree = parser.parse(exp_text)
act_tree = resolve_let(parser.parse(text), let_dict)
self.assertEqual(exp_tree, act_tree)
def test_forbid_nonexistent_mapping(self):
"""Test that we throw an error when attempting to map to a nonexistent register."""
setup_text = "register r[7]; map a q[1]"
gate_text = "foo a"
with self.assertRaises(Exception):
parser = make_lark_parser()
map_dict, register_dict = extract_map(parser.parse(setup_text))
resolve_map(parser.parse(gate_text), map_dict, register_dict)
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_forbid_mapping_whole_register(self):
"""Test that we throw an error when using a mapping in a context where a register element is expected."""
setup_text = "register r[7]; map a r"
gate_text = "foo a"
with self.assertRaises(Exception):
parser = make_lark_parser()
map_dict, register_dict = extract_map(parser.parse(setup_text))
resolve_map(parser.parse(gate_text), map_dict, register_dict)
def test_let_statement(self):
"""Test parsing the let statement"""
text = "let pi 3.14"
parser = make_lark_parser(start="let_statement")
tree = parser.parse(text)
exp_tree = self.make_let_statement("pi", 3.14)
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_replace_gate_arg(self):
"""Test replacing a single gate argument."""
let_dict = {Identifier.parse("a"): 1}
parser = make_lark_parser(start="gate_statement")
text = "g a"
exp_text = "g 1"
exp_tree = parser.parse(exp_text)
act_tree = resolve_let(parser.parse(text), let_dict)
self.assertEqual(exp_tree, act_tree)
def test_usepulses_statement(self):
"""Test parsing an usepulses statement."""
text = "usepulses foo"
parser = make_lark_parser(start="usepulses_statement")
tree = parser.parse(text)
exp_tree = self.make_usepulses_statement(None,
[self.make_as_clause("foo")])
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_usepulses_from_as_statement(self):
text = "from foo usepulses bar0 as bar1"
parser = make_lark_parser(start="usepulses_statement")
tree = parser.parse(text)
exp_tree = self.make_usepulses_statement(
self.make_from_clause("foo"),
[self.make_as_clause("bar0", "bar1")])
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_gate_with_array_element(self):
"""Test a gate with an argument that is an element of an array."""
text = "g q[0]"
parser = make_lark_parser(start="gate_statement")
tree = parser.parse(text)
exp_tree = self.make_gate_statement(
"g", self.make_array_element_qual("q", 0))
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_serial_gate_block(self):
"""Test a serial gate block with a separator."""
text = "{g 0 ; h 1}"
parser = make_lark_parser(start="gate_block")
tree = parser.parse(text)
exp_tree = self.make_serial_gate_block(
self.make_gate_statement("g", 0), self.make_gate_statement("h", 1))
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_reg(self):
"""Test parsing the register statement"""
text = "register q[3]"
parser = make_lark_parser(start="register_statement")
tree = parser.parse(text)
exp_tree = self.make_register_statement(
self.make_array_declaration("q", 3))
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_loop_statement(self):
"""Test creating a loop."""
text = "loop 1 { g0 1 }"
parser = make_lark_parser(start="loop_statement")
tree = parser.parse(text)
exp_tree = self.make_loop_statement(
1, self.make_serial_gate_block(self.make_gate_statement("g0", 1)))
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_qualified_loop_count(self):
text = "loop foo.a { g }"
parser = make_lark_parser(start="loop_statement")
tree = parser.parse(text)
exp_tree = self.make_loop_statement(
"foo.a",
self.make_serial_gate_block(self.make_gate_statement("g")))
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_macro_definition_two_lines(self):
"""Test defining a macro with no statements on two lines."""
text = "macro mymacro a {\n}"
parser = make_lark_parser(start="macro_definition")
tree = parser.parse(text)
gate_block = self.make_serial_gate_block()
exp_tree = self.make_macro_statement("mymacro", "a", gate_block)
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
def test_parallel_gate_block_nosep(self):
"""Test a parallel gate block with a separator."""
text = "<g 0 \n h 1>"
parser = make_lark_parser(start="gate_block")
tree = parser.parse(text)
exp_tree = self.make_parallel_gate_block(
self.make_gate_statement("g", 0), self.make_gate_statement("h", 1))
act_tree = self.simplify_tree(tree)
self.assertEqual(exp_tree, act_tree)
