GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

mirrored fromhttps://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/src/interpret

compiler/qsc/src/interpret/package_tests.rs

170lines · modecode

RawDownload
Latest commit unavailable.
1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3
4use crate::{interpret::Interpreter, packages::BuildableProgram};
5use indoc::indoc;
6use qsc_data_structures::{language_features::LanguageFeatures, target::TargetCapabilityFlags};
7use qsc_eval::output::CursorReceiver;
8use qsc_frontend::compile::SourceMap;
9use qsc_passes::PackageType;
10use qsc_project::{PackageGraphSources, PackageInfo};
11use rustc_hash::FxHashMap;
12
13#[test]
14fn import_and_call_reexport() {
15 let pkg_graph: PackageGraphSources = PackageGraphSources {
16 root: PackageInfo {
17 sources: vec![(
18 "PackageB.qs".into(),
19 indoc! {"
20 import Foo.DependencyA.Foo;
21 function Main() : Unit {
22 Foo([1, 2]);
23 Foo.DependencyA.MagicFunction();
24 }"}
25 .into(),
26 )],
27 language_features: LanguageFeatures::default(),
28 dependencies: [("Foo".into(), "PackageAKey".into())].into_iter().collect(),
29 package_type: None,
30 },
31 packages: [(
32 "PackageAKey".into(),
33 PackageInfo {
34 sources: vec![(
35 "Foo.qs".into(),
36 r#"
37 namespace DependencyA {
38 function MagicFunction() : Unit {
39 Message("hello from dependency A!");
40 }
41 export MagicFunction, Microsoft.Quantum.Core.Length as Foo;
42 }
43 "#
44 .into(),
45 )],
46 language_features: LanguageFeatures::default(),
47 dependencies: FxHashMap::default(),
48 package_type: None,
49 },
50 )]
51 .into_iter()
52 .collect(),
53 };
54
55 // This builds all the dependencies
56 let buildable_program = BuildableProgram::new(TargetCapabilityFlags::all(), pkg_graph);
57
58 assert!(
59 buildable_program.dependency_errors.is_empty(),
60 "dependencies should be built without errors"
61 );
62
63 let BuildableProgram {
64 store,
65 user_code,
66 user_code_dependencies,
67 ..
68 } = buildable_program;
69
70 let user_code = SourceMap::new(user_code.sources, None);
71
72 let mut interpreter = Interpreter::new(
73 user_code,
74 PackageType::Exe,
75 TargetCapabilityFlags::all(),
76 LanguageFeatures::default(),
77 store,
78 &user_code_dependencies,
79 )
80 .expect("interpreter creation should succeed");
81
82 let mut cursor = std::io::Cursor::new(Vec::<u8>::new());
83 let mut receiver = CursorReceiver::new(&mut cursor);
84 let res = interpreter.eval_entry(&mut receiver);
85
86 assert!(res.is_ok(), "evaluation should succeed");
87
88 let output = String::from_utf8(cursor.into_inner()).expect("output should be valid utf-8");
89
90 assert_eq!(output, "hello from dependency A!\n");
91}
92
93#[test]
94fn directly_call_reexport() {
95 let pkg_graph: PackageGraphSources = PackageGraphSources {
96 root: PackageInfo {
97 sources: vec![(
98 "PackageB.qs".into(),
99 indoc! {"
100 function Main() : Unit {
101 Foo.DependencyA.Foo([1, 2]);
102 Foo.DependencyA.MagicFunction();
103 }"}
104 .into(),
105 )],
106 language_features: LanguageFeatures::default(),
107 dependencies: [("Foo".into(), "PackageAKey".into())].into_iter().collect(),
108 package_type: None,
109 },
110 packages: [(
111 "PackageAKey".into(),
112 PackageInfo {
113 sources: vec![(
114 "Foo.qs".into(),
115 r#"
116 namespace DependencyA {
117 function MagicFunction() : Unit {
118 Message("hello from dependency A!");
119 }
120 export MagicFunction, Microsoft.Quantum.Core.Length as Foo;
121 }
122 "#
123 .into(),
124 )],
125 language_features: LanguageFeatures::default(),
126 dependencies: FxHashMap::default(),
127 package_type: None,
128 },
129 )]
130 .into_iter()
131 .collect(),
132 };
133
134 // This builds all the dependencies
135 let buildable_program = BuildableProgram::new(TargetCapabilityFlags::all(), pkg_graph);
136
137 assert!(
138 buildable_program.dependency_errors.is_empty(),
139 "dependencies should be built without errors"
140 );
141
142 let BuildableProgram {
143 store,
144 user_code,
145 user_code_dependencies,
146 ..
147 } = buildable_program;
148
149 let user_code = SourceMap::new(user_code.sources, None);
150
151 let mut interpreter = Interpreter::new(
152 user_code,
153 PackageType::Exe,
154 TargetCapabilityFlags::all(),
155 LanguageFeatures::default(),
156 store,
157 &user_code_dependencies,
158 )
159 .expect("interpreter creation should succeed");
160
161 let mut cursor = std::io::Cursor::new(Vec::<u8>::new());
162 let mut receiver = CursorReceiver::new(&mut cursor);
163 let res = interpreter.eval_entry(&mut receiver);
164
165 assert!(res.is_ok(), "evaluation should succeed");
166
167 let output = String::from_utf8(cursor.into_inner()).expect("output should be valid utf-8");
168
169 assert_eq!(output, "hello from dependency A!\n");
170}
171