GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

mirrored from https://github.com/microsoft/qdkAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
copilot/fix-2145

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

qdk/compiler/qsc_circuit/src/operations

compiler/qsc_circuit/src/operations/tests.rs

155lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3
4use super::*;
5use expect_test::expect;
6use qsc_data_structures::{
7 functors::FunctorApp, language_features::LanguageFeatures, target::TargetCapabilityFlags,
8};
9use qsc_frontend::compile::{compile, core, std, PackageStore, SourceMap};
10use qsc_hir::hir::{Item, ItemKind};
11
12fn compile_one_operation(code: &str) -> (Item, String) {
13 let core_pkg = core();
14 let mut store = PackageStore::new(core_pkg);
15 let std = std(&store, TargetCapabilityFlags::empty());
16 let std = store.insert(std);
17
18 let sources = SourceMap::new([("test".into(), code.into())], None);
19 let unit = compile(
20 &store,
21 &[(std, None)],
22 sources,
23 TargetCapabilityFlags::empty(),
24 LanguageFeatures::default(),
25 );
26 let mut callables = unit.package.items.values().filter_map(|i| {
27 if let ItemKind::Callable(decl) = &i.kind {
28 Some((i, decl.name.name.clone()))
29 } else {
30 None
31 }
32 });
33 let mut namespaces = unit.package.items.values().filter_map(|i| {
34 if let ItemKind::Namespace(ident, _) = &i.kind {
35 Some(ident.clone())
36 } else {
37 None
38 }
39 });
40 let (only_callable, callable_name) = callables.next().expect("Expected exactly one callable");
41 assert!(callables.next().is_none(), "Expected exactly one callable");
42 let only_namespace = namespaces.next().expect("Expected exactly one namespace");
43 assert!(
44 namespaces.next().is_none(),
45 "Expected exactly one namespace"
46 );
47 (
48 only_callable.clone(),
49 format!("{}.{callable_name}", only_namespace.name()),
50 )
51}
52
53#[test]
54fn no_params() {
55 let (item, operation) = compile_one_operation(
56 r"
57 namespace Test {
58 operation Test() : Result[] {
59 }
60 }
61 ",
62 );
63 let expr = entry_expr_for_qubit_operation(&item, FunctorApp::default(), &operation);
64 expect![[r#"
65 Ok(
66 "{\n use qs = Qubit[0];\n (Test.Test)();\n let r: Result[] = [];\n r\n }",
67 )
68 "#]]
69 .assert_debug_eq(&expr);
70}
71
72#[test]
73fn non_qubit_params() {
74 let (item, operation) = compile_one_operation(
75 r"
76 namespace Test {
77 operation Test(q1: Qubit, q2: Qubit, i: Int) : Result[] {
78 }
79 }
80 ",
81 );
82 let expr = entry_expr_for_qubit_operation(&item, FunctorApp::default(), &operation);
83 expect![[r#"
84 Err(
85 NoQubitParameters,
86 )
87 "#]]
88 .assert_debug_eq(&expr);
89}
90
91#[test]
92fn non_qubit_array_param() {
93 let (item, operation) = compile_one_operation(
94 r"
95 namespace Test {
96 operation Test(q1: Qubit[], q2: Qubit[][], i: Int[]) : Result[] {
97 }
98 }
99 ",
100 );
101 let expr = entry_expr_for_qubit_operation(&item, FunctorApp::default(), &operation);
102 expect![[r#"
103 Err(
104 NoQubitParameters,
105 )
106 "#]]
107 .assert_debug_eq(&expr);
108}
109
110#[test]
111fn qubit_params() {
112 let (item, operation) = compile_one_operation(
113 r"
114 namespace Test {
115 operation Test(q1: Qubit, q2: Qubit) : Result[] {
116 }
117 }
118 ",
119 );
120
121 let expr = entry_expr_for_qubit_operation(&item, FunctorApp::default(), &operation)
122 .expect("expression expected");
123
124 expect![[r"
125 {
126 use qs = Qubit[2];
127 (Test.Test)(qs[0], qs[1]);
128 let r: Result[] = [];
129 r
130 }"]]
131 .assert_eq(&expr);
132}
133
134#[test]
135fn qubit_array_params() {
136 let (item, operation) = compile_one_operation(
137 r"
138 namespace Test {
139 operation Test(q1: Qubit[], q2: Qubit[][], q3: Qubit[][][], q: Qubit) : Result[] {
140 }
141 }
142 ",
143 );
144
145 let expr = entry_expr_for_qubit_operation(&item, FunctorApp::default(), &operation)
146 .expect("expression expected");
147
148 expect![[r"
149 {
150 use qs = Qubit[15];
151 (Test.Test)(qs[0..1], Microsoft.Quantum.Arrays.Chunks(2, qs[2..5]), Microsoft.Quantum.Arrays.Chunks(2, Microsoft.Quantum.Arrays.Chunks(2, qs[6..13])), qs[14]);
152 let r: Result[] = [];
153 r
154 }"]].assert_eq(&expr);
155}
156