GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

microsoft/qdk

Public

mirrored fromhttps://github.com/microsoft/qdkAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
iadavis/pipeline-issue-debugging

Branches

Tags

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

Clone

HTTPS

Download ZIP

qdk/source/compiler/qsc/src/interpret

source/compiler/qsc/src/interpret/package_tests.rs

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