aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/test_utils/src/fixture.rs288
-rw-r--r--crates/test_utils/src/lib.rs292
2 files changed, 292 insertions, 288 deletions
diff --git a/crates/test_utils/src/fixture.rs b/crates/test_utils/src/fixture.rs
new file mode 100644
index 000000000..d0a732031
--- /dev/null
+++ b/crates/test_utils/src/fixture.rs
@@ -0,0 +1,288 @@
1use ra_cfg::CfgOptions;
2use rustc_hash::FxHashMap;
3use stdx::split1;
4
5#[derive(Debug, Eq, PartialEq)]
6pub struct FixtureEntry {
7 pub meta: FixtureMeta,
8 pub text: String,
9}
10
11#[derive(Debug, Eq, PartialEq)]
12pub enum FixtureMeta {
13 Root { path: String },
14 File(FileMeta),
15}
16
17#[derive(Debug, Eq, PartialEq)]
18pub struct FileMeta {
19 pub path: String,
20 pub crate_name: Option<String>,
21 pub deps: Vec<String>,
22 pub cfg: CfgOptions,
23 pub edition: Option<String>,
24 pub env: FxHashMap<String, String>,
25}
26
27impl FixtureMeta {
28 pub fn path(&self) -> &str {
29 match self {
30 FixtureMeta::Root { path } => &path,
31 FixtureMeta::File(f) => &f.path,
32 }
33 }
34
35 pub fn crate_name(&self) -> Option<&String> {
36 match self {
37 FixtureMeta::File(f) => f.crate_name.as_ref(),
38 _ => None,
39 }
40 }
41
42 pub fn cfg_options(&self) -> Option<&CfgOptions> {
43 match self {
44 FixtureMeta::File(f) => Some(&f.cfg),
45 _ => None,
46 }
47 }
48
49 pub fn edition(&self) -> Option<&String> {
50 match self {
51 FixtureMeta::File(f) => f.edition.as_ref(),
52 _ => None,
53 }
54 }
55
56 pub fn env(&self) -> impl Iterator<Item = (&String, &String)> {
57 struct EnvIter<'a> {
58 iter: Option<std::collections::hash_map::Iter<'a, String, String>>,
59 }
60
61 impl<'a> EnvIter<'a> {
62 fn new(meta: &'a FixtureMeta) -> Self {
63 Self {
64 iter: match meta {
65 FixtureMeta::File(f) => Some(f.env.iter()),
66 _ => None,
67 },
68 }
69 }
70 }
71
72 impl<'a> Iterator for EnvIter<'a> {
73 type Item = (&'a String, &'a String);
74 fn next(&mut self) -> Option<Self::Item> {
75 self.iter.as_mut().and_then(|i| i.next())
76 }
77 }
78
79 EnvIter::new(self)
80 }
81}
82
83/// Same as `parse_fixture`, except it allow empty fixture
84pub fn parse_single_fixture(ra_fixture: &str) -> Option<FixtureEntry> {
85 if !ra_fixture.lines().any(|it| it.trim_start().starts_with("//-")) {
86 return None;
87 }
88
89 let fixtures = parse_fixture(ra_fixture);
90 if fixtures.len() > 1 {
91 panic!("too many fixtures");
92 }
93 fixtures.into_iter().nth(0)
94}
95
96/// Parses text which looks like this:
97///
98/// ```not_rust
99/// //- some meta
100/// line 1
101/// line 2
102/// // - other meta
103/// ```
104pub fn parse_fixture(ra_fixture: &str) -> Vec<FixtureEntry> {
105 let fixture = indent_first_line(ra_fixture);
106 let margin = fixture_margin(&fixture);
107
108 let mut lines = fixture
109 .split('\n') // don't use `.lines` to not drop `\r\n`
110 .enumerate()
111 .filter_map(|(ix, line)| {
112 if line.len() >= margin {
113 assert!(line[..margin].trim().is_empty());
114 let line_content = &line[margin..];
115 if !line_content.starts_with("//-") {
116 assert!(
117 !line_content.contains("//-"),
118 r#"Metadata line {} has invalid indentation. All metadata lines need to have the same indentation.
119The offending line: {:?}"#,
120 ix,
121 line
122 );
123 }
124 Some(line_content)
125 } else {
126 assert!(line.trim().is_empty());
127 None
128 }
129 });
130
131 let mut res: Vec<FixtureEntry> = Vec::new();
132 for line in lines.by_ref() {
133 if line.starts_with("//-") {
134 let meta = line["//-".len()..].trim().to_string();
135 let meta = parse_meta(&meta);
136 res.push(FixtureEntry { meta, text: String::new() })
137 } else if let Some(entry) = res.last_mut() {
138 entry.text.push_str(line);
139 entry.text.push('\n');
140 }
141 }
142 res
143}
144
145//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
146fn parse_meta(meta: &str) -> FixtureMeta {
147 let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
148
149 if components[0] == "root" {
150 let path = components[1].to_string();
151 assert!(path.starts_with("/") && path.ends_with("/"));
152 return FixtureMeta::Root { path };
153 }
154
155 let path = components[0].to_string();
156 assert!(path.starts_with("/"));
157
158 let mut krate = None;
159 let mut deps = Vec::new();
160 let mut edition = None;
161 let mut cfg = CfgOptions::default();
162 let mut env = FxHashMap::default();
163 for component in components[1..].iter() {
164 let (key, value) = split1(component, ':').unwrap();
165 match key {
166 "crate" => krate = Some(value.to_string()),
167 "deps" => deps = value.split(',').map(|it| it.to_string()).collect(),
168 "edition" => edition = Some(value.to_string()),
169 "cfg" => {
170 for key in value.split(',') {
171 match split1(key, '=') {
172 None => cfg.insert_atom(key.into()),
173 Some((k, v)) => cfg.insert_key_value(k.into(), v.into()),
174 }
175 }
176 }
177 "env" => {
178 for key in value.split(',') {
179 if let Some((k, v)) = split1(key, '=') {
180 env.insert(k.into(), v.into());
181 }
182 }
183 }
184 _ => panic!("bad component: {:?}", component),
185 }
186 }
187
188 FixtureMeta::File(FileMeta { path, crate_name: krate, deps, edition, cfg, env })
189}
190
191/// Adjusts the indentation of the first line to the minimum indentation of the rest of the lines.
192/// This allows fixtures to start off in a different indentation, e.g. to align the first line with
193/// the other lines visually:
194/// ```
195/// let fixture = "//- /lib.rs
196/// mod foo;
197/// //- /foo.rs
198/// fn bar() {}
199/// ";
200/// assert_eq!(fixture_margin(fixture),
201/// " //- /lib.rs
202/// mod foo;
203/// //- /foo.rs
204/// fn bar() {}
205/// ")
206/// ```
207fn indent_first_line(fixture: &str) -> String {
208 if fixture.is_empty() {
209 return String::new();
210 }
211 let mut lines = fixture.lines();
212 let first_line = lines.next().unwrap();
213 if first_line.contains("//-") {
214 let rest = lines.collect::<Vec<_>>().join("\n");
215 let fixed_margin = fixture_margin(&rest);
216 let fixed_indent = fixed_margin - indent_len(first_line);
217 format!("\n{}{}\n{}", " ".repeat(fixed_indent), first_line, rest)
218 } else {
219 fixture.to_owned()
220 }
221}
222
223fn fixture_margin(fixture: &str) -> usize {
224 fixture
225 .lines()
226 .filter(|it| it.trim_start().starts_with("//-"))
227 .map(indent_len)
228 .next()
229 .expect("empty fixture")
230}
231
232fn indent_len(s: &str) -> usize {
233 s.len() - s.trim_start().len()
234}
235
236#[test]
237#[should_panic]
238fn parse_fixture_checks_further_indented_metadata() {
239 parse_fixture(
240 r"
241 //- /lib.rs
242 mod bar;
243
244 fn foo() {}
245 //- /bar.rs
246 pub fn baz() {}
247 ",
248 );
249}
250
251#[test]
252fn parse_fixture_can_handle_dedented_first_line() {
253 let fixture = "//- /lib.rs
254 mod foo;
255 //- /foo.rs
256 struct Bar;
257";
258 assert_eq!(
259 parse_fixture(fixture),
260 parse_fixture(
261 "//- /lib.rs
262mod foo;
263//- /foo.rs
264struct Bar;
265"
266 )
267 )
268}
269
270#[test]
271fn parse_fixture_gets_full_meta() {
272 let parsed = parse_fixture(
273 r"
274 //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
275 mod m;
276 ",
277 );
278 assert_eq!(1, parsed.len());
279
280 let parsed = &parsed[0];
281 assert_eq!("mod m;\n\n", parsed.text);
282
283 let meta = &parsed.meta;
284 assert_eq!("foo", meta.crate_name().unwrap());
285 assert_eq!("/lib.rs", meta.path());
286 assert!(meta.cfg_options().is_some());
287 assert_eq!(2, meta.env().count());
288}
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index fd917e43b..f22fcc8b2 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -8,6 +8,7 @@
8 8
9#[macro_use] 9#[macro_use]
10pub mod mark; 10pub mod mark;
11mod fixture;
11 12
12use std::{ 13use std::{
13 env, fs, 14 env, fs,
@@ -15,13 +16,13 @@ use std::{
15}; 16};
16 17
17use serde_json::Value; 18use serde_json::Value;
18use stdx::split1;
19use text_size::{TextRange, TextSize}; 19use text_size::{TextRange, TextSize};
20 20
21pub use difference::Changeset as __Changeset;
21pub use ra_cfg::CfgOptions; 22pub use ra_cfg::CfgOptions;
22pub use rustc_hash::FxHashMap; 23pub use rustc_hash::FxHashMap;
23 24
24pub use difference::Changeset as __Changeset; 25pub use crate::fixture::{parse_fixture, parse_single_fixture, FixtureEntry, FixtureMeta};
25 26
26pub const CURSOR_MARKER: &str = "<|>"; 27pub const CURSOR_MARKER: &str = "<|>";
27 28
@@ -97,7 +98,7 @@ impl From<RangeOrOffset> for TextRange {
97 fn from(selection: RangeOrOffset) -> Self { 98 fn from(selection: RangeOrOffset) -> Self {
98 match selection { 99 match selection {
99 RangeOrOffset::Range(it) => it, 100 RangeOrOffset::Range(it) => it,
100 RangeOrOffset::Offset(it) => TextRange::new(it, it), 101 RangeOrOffset::Offset(it) => TextRange::empty(it),
101 } 102 }
102 } 103 }
103} 104}
@@ -159,291 +160,6 @@ pub fn add_cursor(text: &str, offset: TextSize) -> String {
159 res 160 res
160} 161}
161 162
162#[derive(Debug, Eq, PartialEq)]
163pub struct FixtureEntry {
164 pub meta: FixtureMeta,
165 pub text: String,
166}
167
168#[derive(Debug, Eq, PartialEq)]
169pub enum FixtureMeta {
170 Root { path: String },
171 File(FileMeta),
172}
173
174#[derive(Debug, Eq, PartialEq)]
175pub struct FileMeta {
176 pub path: String,
177 pub crate_name: Option<String>,
178 pub deps: Vec<String>,
179 pub cfg: CfgOptions,
180 pub edition: Option<String>,
181 pub env: FxHashMap<String, String>,
182}
183
184impl FixtureMeta {
185 pub fn path(&self) -> &str {
186 match self {
187 FixtureMeta::Root { path } => &path,
188 FixtureMeta::File(f) => &f.path,
189 }
190 }
191
192 pub fn crate_name(&self) -> Option<&String> {
193 match self {
194 FixtureMeta::File(f) => f.crate_name.as_ref(),
195 _ => None,
196 }
197 }
198
199 pub fn cfg_options(&self) -> Option<&CfgOptions> {
200 match self {
201 FixtureMeta::File(f) => Some(&f.cfg),
202 _ => None,
203 }
204 }
205
206 pub fn edition(&self) -> Option<&String> {
207 match self {
208 FixtureMeta::File(f) => f.edition.as_ref(),
209 _ => None,
210 }
211 }
212
213 pub fn env(&self) -> impl Iterator<Item = (&String, &String)> {
214 struct EnvIter<'a> {
215 iter: Option<std::collections::hash_map::Iter<'a, String, String>>,
216 }
217
218 impl<'a> EnvIter<'a> {
219 fn new(meta: &'a FixtureMeta) -> Self {
220 Self {
221 iter: match meta {
222 FixtureMeta::File(f) => Some(f.env.iter()),
223 _ => None,
224 },
225 }
226 }
227 }
228
229 impl<'a> Iterator for EnvIter<'a> {
230 type Item = (&'a String, &'a String);
231 fn next(&mut self) -> Option<Self::Item> {
232 self.iter.as_mut().and_then(|i| i.next())
233 }
234 }
235
236 EnvIter::new(self)
237 }
238}
239
240/// Parses text which looks like this:
241///
242/// ```not_rust
243/// //- some meta
244/// line 1
245/// line 2
246/// // - other meta
247/// ```
248pub fn parse_fixture(ra_fixture: &str) -> Vec<FixtureEntry> {
249 let fixture = indent_first_line(ra_fixture);
250 let margin = fixture_margin(&fixture);
251
252 let mut lines = fixture
253 .split('\n') // don't use `.lines` to not drop `\r\n`
254 .enumerate()
255 .filter_map(|(ix, line)| {
256 if line.len() >= margin {
257 assert!(line[..margin].trim().is_empty());
258 let line_content = &line[margin..];
259 if !line_content.starts_with("//-") {
260 assert!(
261 !line_content.contains("//-"),
262 r#"Metadata line {} has invalid indentation. All metadata lines need to have the same indentation.
263The offending line: {:?}"#,
264 ix,
265 line
266 );
267 }
268 Some(line_content)
269 } else {
270 assert!(line.trim().is_empty());
271 None
272 }
273 });
274
275 let mut res: Vec<FixtureEntry> = Vec::new();
276 for line in lines.by_ref() {
277 if line.starts_with("//-") {
278 let meta = line["//-".len()..].trim().to_string();
279 let meta = parse_meta(&meta);
280 res.push(FixtureEntry { meta, text: String::new() })
281 } else if let Some(entry) = res.last_mut() {
282 entry.text.push_str(line);
283 entry.text.push('\n');
284 }
285 }
286 res
287}
288
289//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
290fn parse_meta(meta: &str) -> FixtureMeta {
291 let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
292
293 if components[0] == "root" {
294 let path = components[1].to_string();
295 assert!(path.starts_with("/") && path.ends_with("/"));
296 return FixtureMeta::Root { path };
297 }
298
299 let path = components[0].to_string();
300 assert!(path.starts_with("/"));
301
302 let mut krate = None;
303 let mut deps = Vec::new();
304 let mut edition = None;
305 let mut cfg = CfgOptions::default();
306 let mut env = FxHashMap::default();
307 for component in components[1..].iter() {
308 let (key, value) = split1(component, ':').unwrap();
309 match key {
310 "crate" => krate = Some(value.to_string()),
311 "deps" => deps = value.split(',').map(|it| it.to_string()).collect(),
312 "edition" => edition = Some(value.to_string()),
313 "cfg" => {
314 for key in value.split(',') {
315 match split1(key, '=') {
316 None => cfg.insert_atom(key.into()),
317 Some((k, v)) => cfg.insert_key_value(k.into(), v.into()),
318 }
319 }
320 }
321 "env" => {
322 for key in value.split(',') {
323 if let Some((k, v)) = split1(key, '=') {
324 env.insert(k.into(), v.into());
325 }
326 }
327 }
328 _ => panic!("bad component: {:?}", component),
329 }
330 }
331
332 FixtureMeta::File(FileMeta { path, crate_name: krate, deps, edition, cfg, env })
333}
334
335/// Adjusts the indentation of the first line to the minimum indentation of the rest of the lines.
336/// This allows fixtures to start off in a different indentation, e.g. to align the first line with
337/// the other lines visually:
338/// ```
339/// let fixture = "//- /lib.rs
340/// mod foo;
341/// //- /foo.rs
342/// fn bar() {}
343/// ";
344/// assert_eq!(fixture_margin(fixture),
345/// " //- /lib.rs
346/// mod foo;
347/// //- /foo.rs
348/// fn bar() {}
349/// ")
350/// ```
351fn indent_first_line(fixture: &str) -> String {
352 if fixture.is_empty() {
353 return String::new();
354 }
355 let mut lines = fixture.lines();
356 let first_line = lines.next().unwrap();
357 if first_line.contains("//-") {
358 let rest = lines.collect::<Vec<_>>().join("\n");
359 let fixed_margin = fixture_margin(&rest);
360 let fixed_indent = fixed_margin - indent_len(first_line);
361 format!("\n{}{}\n{}", " ".repeat(fixed_indent), first_line, rest)
362 } else {
363 fixture.to_owned()
364 }
365}
366
367fn fixture_margin(fixture: &str) -> usize {
368 fixture
369 .lines()
370 .filter(|it| it.trim_start().starts_with("//-"))
371 .map(indent_len)
372 .next()
373 .expect("empty fixture")
374}
375
376fn indent_len(s: &str) -> usize {
377 s.len() - s.trim_start().len()
378}
379
380#[test]
381#[should_panic]
382fn parse_fixture_checks_further_indented_metadata() {
383 parse_fixture(
384 r"
385 //- /lib.rs
386 mod bar;
387
388 fn foo() {}
389 //- /bar.rs
390 pub fn baz() {}
391 ",
392 );
393}
394
395#[test]
396fn parse_fixture_can_handle_dedented_first_line() {
397 let fixture = "//- /lib.rs
398 mod foo;
399 //- /foo.rs
400 struct Bar;
401";
402 assert_eq!(
403 parse_fixture(fixture),
404 parse_fixture(
405 "//- /lib.rs
406mod foo;
407//- /foo.rs
408struct Bar;
409"
410 )
411 )
412}
413
414#[test]
415fn parse_fixture_gets_full_meta() {
416 let parsed = parse_fixture(
417 r"
418 //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
419 mod m;
420 ",
421 );
422 assert_eq!(1, parsed.len());
423
424 let parsed = &parsed[0];
425 assert_eq!("mod m;\n\n", parsed.text);
426
427 let meta = &parsed.meta;
428 assert_eq!("foo", meta.crate_name().unwrap());
429 assert_eq!("/lib.rs", meta.path());
430 assert!(meta.cfg_options().is_some());
431 assert_eq!(2, meta.env().count());
432}
433
434/// Same as `parse_fixture`, except it allow empty fixture
435pub fn parse_single_fixture(ra_fixture: &str) -> Option<FixtureEntry> {
436 if !ra_fixture.lines().any(|it| it.trim_start().starts_with("//-")) {
437 return None;
438 }
439
440 let fixtures = parse_fixture(ra_fixture);
441 if fixtures.len() > 1 {
442 panic!("too many fixtures");
443 }
444 fixtures.into_iter().nth(0)
445}
446
447// Comparison functionality borrowed from cargo: 163// Comparison functionality borrowed from cargo:
448 164
449/// Compare a line with an expected pattern. 165/// Compare a line with an expected pattern.