diff options
author | bors[bot] <26634292+bors[bot]@users.noreply.github.com> | 2019-12-29 12:57:24 +0000 |
---|---|---|
committer | GitHub <[email protected]> | 2019-12-29 12:57:24 +0000 |
commit | dc48f89581843248660ceb755bb20469ab6ac0c9 (patch) | |
tree | 05a7e47d1c68c250025be1ce6492f56c15353749 /editors/code/src/test/utils | |
parent | cdcb3d3833d3d5b37b2cd4dac91a6e9366f20aea (diff) | |
parent | 899dbebd02b41b12d89c9f485e85208b39b81932 (diff) |
Merge #2668
2668: In-server cargo check watching r=matklad a=kiljacken
Opening a draft now so people can follow the progress, and comment if they spot something stupid.
Things that need doing:
- [x] Running cargo check on save
- [x] Pipe through configuration options from client
- [x] Tests for parsing behavior
- [x] Remove existing cargo watch support from VSCode extension
- [x] Progress notification in VSCode extension using LSP 3.15 `$/progress` notification
- [ ] ~~Rework ra-ide diagnostics to support secondary messages~~
- [ ] ~~Make cargo-check watcher use ra-ide diagnostics~~
~~I'd love some input on whether to try to keep the status bar progress thingy for VSCode? It will require some plumbing, and maintaining yet another rust-analyzer specific LSP notification, which I'm not sure we want to.~~
Fixes #1894
Co-authored-by: Emil Lauridsen <[email protected]>
Diffstat (limited to 'editors/code/src/test/utils')
4 files changed, 0 insertions, 595 deletions
diff --git a/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts b/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts deleted file mode 100644 index 2b25eb705..000000000 --- a/editors/code/src/test/utils/diagnotics/SuggestedFix.test.ts +++ /dev/null | |||
@@ -1,134 +0,0 @@ | |||
1 | import * as assert from 'assert'; | ||
2 | import * as vscode from 'vscode'; | ||
3 | |||
4 | import { SuggestionApplicability } from '../../../utils/diagnostics/rust'; | ||
5 | import SuggestedFix from '../../../utils/diagnostics/SuggestedFix'; | ||
6 | |||
7 | const location1 = new vscode.Location( | ||
8 | vscode.Uri.file('/file/1'), | ||
9 | new vscode.Range(new vscode.Position(1, 2), new vscode.Position(3, 4)), | ||
10 | ); | ||
11 | |||
12 | const location2 = new vscode.Location( | ||
13 | vscode.Uri.file('/file/2'), | ||
14 | new vscode.Range(new vscode.Position(5, 6), new vscode.Position(7, 8)), | ||
15 | ); | ||
16 | |||
17 | describe('SuggestedFix', () => { | ||
18 | describe('isEqual', () => { | ||
19 | it('should treat identical instances as equal', () => { | ||
20 | const suggestion1 = new SuggestedFix( | ||
21 | 'Replace me!', | ||
22 | location1, | ||
23 | 'With this!', | ||
24 | ); | ||
25 | |||
26 | const suggestion2 = new SuggestedFix( | ||
27 | 'Replace me!', | ||
28 | location1, | ||
29 | 'With this!', | ||
30 | ); | ||
31 | |||
32 | assert(suggestion1.isEqual(suggestion2)); | ||
33 | }); | ||
34 | |||
35 | it('should treat instances with different titles as inequal', () => { | ||
36 | const suggestion1 = new SuggestedFix( | ||
37 | 'Replace me!', | ||
38 | location1, | ||
39 | 'With this!', | ||
40 | ); | ||
41 | |||
42 | const suggestion2 = new SuggestedFix( | ||
43 | 'Not the same title!', | ||
44 | location1, | ||
45 | 'With this!', | ||
46 | ); | ||
47 | |||
48 | assert(!suggestion1.isEqual(suggestion2)); | ||
49 | }); | ||
50 | |||
51 | it('should treat instances with different replacements as inequal', () => { | ||
52 | const suggestion1 = new SuggestedFix( | ||
53 | 'Replace me!', | ||
54 | location1, | ||
55 | 'With this!', | ||
56 | ); | ||
57 | |||
58 | const suggestion2 = new SuggestedFix( | ||
59 | 'Replace me!', | ||
60 | location1, | ||
61 | 'With something else!', | ||
62 | ); | ||
63 | |||
64 | assert(!suggestion1.isEqual(suggestion2)); | ||
65 | }); | ||
66 | |||
67 | it('should treat instances with different locations as inequal', () => { | ||
68 | const suggestion1 = new SuggestedFix( | ||
69 | 'Replace me!', | ||
70 | location1, | ||
71 | 'With this!', | ||
72 | ); | ||
73 | |||
74 | const suggestion2 = new SuggestedFix( | ||
75 | 'Replace me!', | ||
76 | location2, | ||
77 | 'With this!', | ||
78 | ); | ||
79 | |||
80 | assert(!suggestion1.isEqual(suggestion2)); | ||
81 | }); | ||
82 | |||
83 | it('should treat instances with different applicability as inequal', () => { | ||
84 | const suggestion1 = new SuggestedFix( | ||
85 | 'Replace me!', | ||
86 | location1, | ||
87 | 'With this!', | ||
88 | SuggestionApplicability.MachineApplicable, | ||
89 | ); | ||
90 | |||
91 | const suggestion2 = new SuggestedFix( | ||
92 | 'Replace me!', | ||
93 | location2, | ||
94 | 'With this!', | ||
95 | SuggestionApplicability.HasPlaceholders, | ||
96 | ); | ||
97 | |||
98 | assert(!suggestion1.isEqual(suggestion2)); | ||
99 | }); | ||
100 | }); | ||
101 | |||
102 | describe('toCodeAction', () => { | ||
103 | it('should map a simple suggestion', () => { | ||
104 | const suggestion = new SuggestedFix( | ||
105 | 'Replace me!', | ||
106 | location1, | ||
107 | 'With this!', | ||
108 | ); | ||
109 | |||
110 | const codeAction = suggestion.toCodeAction(); | ||
111 | assert.strictEqual(codeAction.kind, vscode.CodeActionKind.QuickFix); | ||
112 | assert.strictEqual(codeAction.title, 'Replace me!'); | ||
113 | assert.strictEqual(codeAction.isPreferred, false); | ||
114 | |||
115 | const edit = codeAction.edit; | ||
116 | if (!edit) { | ||
117 | assert.fail('Code Action edit unexpectedly missing'); | ||
118 | return; | ||
119 | } | ||
120 | |||
121 | const editEntries = edit.entries(); | ||
122 | assert.strictEqual(editEntries.length, 1); | ||
123 | |||
124 | const [[editUri, textEdits]] = editEntries; | ||
125 | assert.strictEqual(editUri.toString(), location1.uri.toString()); | ||
126 | |||
127 | assert.strictEqual(textEdits.length, 1); | ||
128 | const [textEdit] = textEdits; | ||
129 | |||
130 | assert(textEdit.range.isEqual(location1.range)); | ||
131 | assert.strictEqual(textEdit.newText, 'With this!'); | ||
132 | }); | ||
133 | }); | ||
134 | }); | ||
diff --git a/editors/code/src/test/utils/diagnotics/SuggestedFixCollection.test.ts b/editors/code/src/test/utils/diagnotics/SuggestedFixCollection.test.ts deleted file mode 100644 index ef09013f4..000000000 --- a/editors/code/src/test/utils/diagnotics/SuggestedFixCollection.test.ts +++ /dev/null | |||
@@ -1,127 +0,0 @@ | |||
1 | import * as assert from 'assert'; | ||
2 | import * as vscode from 'vscode'; | ||
3 | |||
4 | import SuggestedFix from '../../../utils/diagnostics/SuggestedFix'; | ||
5 | import SuggestedFixCollection from '../../../utils/diagnostics/SuggestedFixCollection'; | ||
6 | |||
7 | const uri1 = vscode.Uri.file('/file/1'); | ||
8 | const uri2 = vscode.Uri.file('/file/2'); | ||
9 | |||
10 | const mockDocument1 = ({ | ||
11 | uri: uri1, | ||
12 | } as unknown) as vscode.TextDocument; | ||
13 | |||
14 | const mockDocument2 = ({ | ||
15 | uri: uri2, | ||
16 | } as unknown) as vscode.TextDocument; | ||
17 | |||
18 | const range1 = new vscode.Range( | ||
19 | new vscode.Position(1, 2), | ||
20 | new vscode.Position(3, 4), | ||
21 | ); | ||
22 | const range2 = new vscode.Range( | ||
23 | new vscode.Position(5, 6), | ||
24 | new vscode.Position(7, 8), | ||
25 | ); | ||
26 | |||
27 | const diagnostic1 = new vscode.Diagnostic(range1, 'First diagnostic'); | ||
28 | const diagnostic2 = new vscode.Diagnostic(range2, 'Second diagnostic'); | ||
29 | |||
30 | // This is a mutable object so return a fresh instance every time | ||
31 | function suggestion1(): SuggestedFix { | ||
32 | return new SuggestedFix( | ||
33 | 'Replace me!', | ||
34 | new vscode.Location(uri1, range1), | ||
35 | 'With this!', | ||
36 | ); | ||
37 | } | ||
38 | |||
39 | describe('SuggestedFixCollection', () => { | ||
40 | it('should add a suggestion then return it as a code action', () => { | ||
41 | const suggestedFixes = new SuggestedFixCollection(); | ||
42 | suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1); | ||
43 | |||
44 | // Specify the document and range that exactly matches | ||
45 | const codeActions = suggestedFixes.provideCodeActions( | ||
46 | mockDocument1, | ||
47 | range1, | ||
48 | ); | ||
49 | |||
50 | assert.strictEqual(codeActions.length, 1); | ||
51 | const [codeAction] = codeActions; | ||
52 | assert.strictEqual(codeAction.title, suggestion1().title); | ||
53 | |||
54 | const { diagnostics } = codeAction; | ||
55 | if (!diagnostics) { | ||
56 | assert.fail('Diagnostics unexpectedly missing'); | ||
57 | return; | ||
58 | } | ||
59 | |||
60 | assert.strictEqual(diagnostics.length, 1); | ||
61 | assert.strictEqual(diagnostics[0], diagnostic1); | ||
62 | }); | ||
63 | |||
64 | it('should not return code actions for different ranges', () => { | ||
65 | const suggestedFixes = new SuggestedFixCollection(); | ||
66 | suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1); | ||
67 | |||
68 | const codeActions = suggestedFixes.provideCodeActions( | ||
69 | mockDocument1, | ||
70 | range2, | ||
71 | ); | ||
72 | |||
73 | assert(!codeActions || codeActions.length === 0); | ||
74 | }); | ||
75 | |||
76 | it('should not return code actions for different documents', () => { | ||
77 | const suggestedFixes = new SuggestedFixCollection(); | ||
78 | suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1); | ||
79 | |||
80 | const codeActions = suggestedFixes.provideCodeActions( | ||
81 | mockDocument2, | ||
82 | range1, | ||
83 | ); | ||
84 | |||
85 | assert(!codeActions || codeActions.length === 0); | ||
86 | }); | ||
87 | |||
88 | it('should not return code actions that have been cleared', () => { | ||
89 | const suggestedFixes = new SuggestedFixCollection(); | ||
90 | suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1); | ||
91 | suggestedFixes.clear(); | ||
92 | |||
93 | const codeActions = suggestedFixes.provideCodeActions( | ||
94 | mockDocument1, | ||
95 | range1, | ||
96 | ); | ||
97 | |||
98 | assert(!codeActions || codeActions.length === 0); | ||
99 | }); | ||
100 | |||
101 | it('should merge identical suggestions together', () => { | ||
102 | const suggestedFixes = new SuggestedFixCollection(); | ||
103 | |||
104 | // Add the same suggestion for two diagnostics | ||
105 | suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic1); | ||
106 | suggestedFixes.addSuggestedFixForDiagnostic(suggestion1(), diagnostic2); | ||
107 | |||
108 | const codeActions = suggestedFixes.provideCodeActions( | ||
109 | mockDocument1, | ||
110 | range1, | ||
111 | ); | ||
112 | |||
113 | assert.strictEqual(codeActions.length, 1); | ||
114 | const [codeAction] = codeActions; | ||
115 | const { diagnostics } = codeAction; | ||
116 | |||
117 | if (!diagnostics) { | ||
118 | assert.fail('Diagnostics unexpectedly missing'); | ||
119 | return; | ||
120 | } | ||
121 | |||
122 | // We should be associated with both diagnostics | ||
123 | assert.strictEqual(diagnostics.length, 2); | ||
124 | assert.strictEqual(diagnostics[0], diagnostic1); | ||
125 | assert.strictEqual(diagnostics[1], diagnostic2); | ||
126 | }); | ||
127 | }); | ||
diff --git a/editors/code/src/test/utils/diagnotics/rust.test.ts b/editors/code/src/test/utils/diagnotics/rust.test.ts deleted file mode 100644 index 358325cc8..000000000 --- a/editors/code/src/test/utils/diagnotics/rust.test.ts +++ /dev/null | |||
@@ -1,236 +0,0 @@ | |||
1 | import * as assert from 'assert'; | ||
2 | import * as fs from 'fs'; | ||
3 | import * as vscode from 'vscode'; | ||
4 | |||
5 | import { | ||
6 | MappedRustDiagnostic, | ||
7 | mapRustDiagnosticToVsCode, | ||
8 | RustDiagnostic, | ||
9 | SuggestionApplicability, | ||
10 | } from '../../../utils/diagnostics/rust'; | ||
11 | |||
12 | function loadDiagnosticFixture(name: string): RustDiagnostic { | ||
13 | const jsonText = fs | ||
14 | .readFileSync( | ||
15 | // We're actually in our JavaScript output directory, climb out | ||
16 | `${__dirname}/../../../../src/test/fixtures/rust-diagnostics/${name}.json`, | ||
17 | ) | ||
18 | .toString(); | ||
19 | |||
20 | return JSON.parse(jsonText); | ||
21 | } | ||
22 | |||
23 | function mapFixtureToVsCode(name: string): MappedRustDiagnostic { | ||
24 | const rd = loadDiagnosticFixture(name); | ||
25 | const mapResult = mapRustDiagnosticToVsCode(rd); | ||
26 | |||
27 | if (!mapResult) { | ||
28 | return assert.fail('Mapping unexpectedly failed'); | ||
29 | } | ||
30 | return mapResult; | ||
31 | } | ||
32 | |||
33 | describe('mapRustDiagnosticToVsCode', () => { | ||
34 | it('should map an incompatible type for trait error', () => { | ||
35 | const { diagnostic, suggestedFixes } = mapFixtureToVsCode( | ||
36 | 'error/E0053', | ||
37 | ); | ||
38 | |||
39 | assert.strictEqual( | ||
40 | diagnostic.severity, | ||
41 | vscode.DiagnosticSeverity.Error, | ||
42 | ); | ||
43 | assert.strictEqual(diagnostic.source, 'rustc'); | ||
44 | assert.strictEqual( | ||
45 | diagnostic.message, | ||
46 | [ | ||
47 | `method \`next\` has an incompatible type for trait`, | ||
48 | `expected type \`fn(&mut ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&ty::Ref<M>>\``, | ||
49 | ` found type \`fn(&ty::list_iter::ListIterator<'list, M>) -> std::option::Option<&'list ty::Ref<M>>\``, | ||
50 | ].join('\n'), | ||
51 | ); | ||
52 | assert.strictEqual(diagnostic.code, 'E0053'); | ||
53 | assert.deepStrictEqual(diagnostic.tags, []); | ||
54 | |||
55 | // No related information | ||
56 | assert.deepStrictEqual(diagnostic.relatedInformation, []); | ||
57 | |||
58 | // There are no suggested fixes | ||
59 | assert.strictEqual(suggestedFixes.length, 0); | ||
60 | }); | ||
61 | |||
62 | it('should map an unused variable warning', () => { | ||
63 | const { diagnostic, suggestedFixes } = mapFixtureToVsCode( | ||
64 | 'warning/unused_variables', | ||
65 | ); | ||
66 | |||
67 | assert.strictEqual( | ||
68 | diagnostic.severity, | ||
69 | vscode.DiagnosticSeverity.Warning, | ||
70 | ); | ||
71 | assert.strictEqual( | ||
72 | diagnostic.message, | ||
73 | [ | ||
74 | 'unused variable: `foo`', | ||
75 | '#[warn(unused_variables)] on by default', | ||
76 | ].join('\n'), | ||
77 | ); | ||
78 | assert.strictEqual(diagnostic.code, 'unused_variables'); | ||
79 | assert.strictEqual(diagnostic.source, 'rustc'); | ||
80 | assert.deepStrictEqual(diagnostic.tags, [ | ||
81 | vscode.DiagnosticTag.Unnecessary, | ||
82 | ]); | ||
83 | |||
84 | // No related information | ||
85 | assert.deepStrictEqual(diagnostic.relatedInformation, []); | ||
86 | |||
87 | // One suggested fix available to prefix the variable | ||
88 | assert.strictEqual(suggestedFixes.length, 1); | ||
89 | const [suggestedFix] = suggestedFixes; | ||
90 | assert.strictEqual( | ||
91 | suggestedFix.title, | ||
92 | 'consider prefixing with an underscore: `_foo`', | ||
93 | ); | ||
94 | assert.strictEqual( | ||
95 | suggestedFix.applicability, | ||
96 | SuggestionApplicability.MachineApplicable, | ||
97 | ); | ||
98 | }); | ||
99 | |||
100 | it('should map a wrong number of parameters error', () => { | ||
101 | const { diagnostic, suggestedFixes } = mapFixtureToVsCode( | ||
102 | 'error/E0061', | ||
103 | ); | ||
104 | |||
105 | assert.strictEqual( | ||
106 | diagnostic.severity, | ||
107 | vscode.DiagnosticSeverity.Error, | ||
108 | ); | ||
109 | assert.strictEqual( | ||
110 | diagnostic.message, | ||
111 | [ | ||
112 | 'this function takes 2 parameters but 3 parameters were supplied', | ||
113 | 'expected 2 parameters', | ||
114 | ].join('\n'), | ||
115 | ); | ||
116 | assert.strictEqual(diagnostic.code, 'E0061'); | ||
117 | assert.strictEqual(diagnostic.source, 'rustc'); | ||
118 | assert.deepStrictEqual(diagnostic.tags, []); | ||
119 | |||
120 | // One related information for the original definition | ||
121 | const relatedInformation = diagnostic.relatedInformation; | ||
122 | if (!relatedInformation) { | ||
123 | assert.fail('Related information unexpectedly undefined'); | ||
124 | return; | ||
125 | } | ||
126 | assert.strictEqual(relatedInformation.length, 1); | ||
127 | const [related] = relatedInformation; | ||
128 | assert.strictEqual(related.message, 'defined here'); | ||
129 | |||
130 | // There are no suggested fixes | ||
131 | assert.strictEqual(suggestedFixes.length, 0); | ||
132 | }); | ||
133 | |||
134 | it('should map a Clippy copy pass by ref warning', () => { | ||
135 | const { diagnostic, suggestedFixes } = mapFixtureToVsCode( | ||
136 | 'clippy/trivially_copy_pass_by_ref', | ||
137 | ); | ||
138 | |||
139 | assert.strictEqual( | ||
140 | diagnostic.severity, | ||
141 | vscode.DiagnosticSeverity.Warning, | ||
142 | ); | ||
143 | assert.strictEqual(diagnostic.source, 'clippy'); | ||
144 | assert.strictEqual( | ||
145 | diagnostic.message, | ||
146 | [ | ||
147 | 'this argument is passed by reference, but would be more efficient if passed by value', | ||
148 | '#[warn(clippy::trivially_copy_pass_by_ref)] implied by #[warn(clippy::all)]', | ||
149 | 'for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#trivially_copy_pass_by_ref', | ||
150 | ].join('\n'), | ||
151 | ); | ||
152 | assert.strictEqual(diagnostic.code, 'trivially_copy_pass_by_ref'); | ||
153 | assert.deepStrictEqual(diagnostic.tags, []); | ||
154 | |||
155 | // One related information for the lint definition | ||
156 | const relatedInformation = diagnostic.relatedInformation; | ||
157 | if (!relatedInformation) { | ||
158 | assert.fail('Related information unexpectedly undefined'); | ||
159 | return; | ||
160 | } | ||
161 | assert.strictEqual(relatedInformation.length, 1); | ||
162 | const [related] = relatedInformation; | ||
163 | assert.strictEqual(related.message, 'lint level defined here'); | ||
164 | |||
165 | // One suggested fix to pass by value | ||
166 | assert.strictEqual(suggestedFixes.length, 1); | ||
167 | const [suggestedFix] = suggestedFixes; | ||
168 | assert.strictEqual( | ||
169 | suggestedFix.title, | ||
170 | 'consider passing by value instead: `self`', | ||
171 | ); | ||
172 | // Clippy does not mark this with any applicability | ||
173 | assert.strictEqual( | ||
174 | suggestedFix.applicability, | ||
175 | SuggestionApplicability.Unspecified, | ||
176 | ); | ||
177 | }); | ||
178 | |||
179 | it('should map a mismatched type error', () => { | ||
180 | const { diagnostic, suggestedFixes } = mapFixtureToVsCode( | ||
181 | 'error/E0308', | ||
182 | ); | ||
183 | |||
184 | assert.strictEqual( | ||
185 | diagnostic.severity, | ||
186 | vscode.DiagnosticSeverity.Error, | ||
187 | ); | ||
188 | assert.strictEqual( | ||
189 | diagnostic.message, | ||
190 | ['mismatched types', 'expected usize, found u32'].join('\n'), | ||
191 | ); | ||
192 | assert.strictEqual(diagnostic.code, 'E0308'); | ||
193 | assert.strictEqual(diagnostic.source, 'rustc'); | ||
194 | assert.deepStrictEqual(diagnostic.tags, []); | ||
195 | |||
196 | // No related information | ||
197 | assert.deepStrictEqual(diagnostic.relatedInformation, []); | ||
198 | |||
199 | // There are no suggested fixes | ||
200 | assert.strictEqual(suggestedFixes.length, 0); | ||
201 | }); | ||
202 | |||
203 | it('should map a macro invocation location to normal file path', () => { | ||
204 | const { location, diagnostic, suggestedFixes } = mapFixtureToVsCode( | ||
205 | 'error/E0277', | ||
206 | ); | ||
207 | |||
208 | assert.strictEqual( | ||
209 | diagnostic.severity, | ||
210 | vscode.DiagnosticSeverity.Error, | ||
211 | ); | ||
212 | assert.strictEqual( | ||
213 | diagnostic.message, | ||
214 | [ | ||
215 | "can't compare `{integer}` with `&str`", | ||
216 | 'the trait `std::cmp::PartialEq<&str>` is not implemented for `{integer}`', | ||
217 | ].join('\n'), | ||
218 | ); | ||
219 | assert.strictEqual(diagnostic.code, 'E0277'); | ||
220 | assert.strictEqual(diagnostic.source, 'rustc'); | ||
221 | assert.deepStrictEqual(diagnostic.tags, []); | ||
222 | |||
223 | // No related information | ||
224 | assert.deepStrictEqual(diagnostic.relatedInformation, []); | ||
225 | |||
226 | // There are no suggested fixes | ||
227 | assert.strictEqual(suggestedFixes.length, 0); | ||
228 | |||
229 | // The file url should be normal file | ||
230 | // Ignore the first part because it depends on vs workspace location | ||
231 | assert.strictEqual( | ||
232 | location.uri.path.substr(-'src/main.rs'.length), | ||
233 | 'src/main.rs', | ||
234 | ); | ||
235 | }); | ||
236 | }); | ||
diff --git a/editors/code/src/test/utils/diagnotics/vscode.test.ts b/editors/code/src/test/utils/diagnotics/vscode.test.ts deleted file mode 100644 index 4944dd032..000000000 --- a/editors/code/src/test/utils/diagnotics/vscode.test.ts +++ /dev/null | |||
@@ -1,98 +0,0 @@ | |||
1 | import * as assert from 'assert'; | ||
2 | import * as vscode from 'vscode'; | ||
3 | |||
4 | import { areDiagnosticsEqual } from '../../../utils/diagnostics/vscode'; | ||
5 | |||
6 | const range1 = new vscode.Range( | ||
7 | new vscode.Position(1, 2), | ||
8 | new vscode.Position(3, 4), | ||
9 | ); | ||
10 | |||
11 | const range2 = new vscode.Range( | ||
12 | new vscode.Position(5, 6), | ||
13 | new vscode.Position(7, 8), | ||
14 | ); | ||
15 | |||
16 | describe('areDiagnosticsEqual', () => { | ||
17 | it('should treat identical diagnostics as equal', () => { | ||
18 | const diagnostic1 = new vscode.Diagnostic( | ||
19 | range1, | ||
20 | 'Hello, world!', | ||
21 | vscode.DiagnosticSeverity.Error, | ||
22 | ); | ||
23 | |||
24 | const diagnostic2 = new vscode.Diagnostic( | ||
25 | range1, | ||
26 | 'Hello, world!', | ||
27 | vscode.DiagnosticSeverity.Error, | ||
28 | ); | ||
29 | |||
30 | assert(areDiagnosticsEqual(diagnostic1, diagnostic2)); | ||
31 | }); | ||
32 | |||
33 | it('should treat diagnostics with different sources as inequal', () => { | ||
34 | const diagnostic1 = new vscode.Diagnostic( | ||
35 | range1, | ||
36 | 'Hello, world!', | ||
37 | vscode.DiagnosticSeverity.Error, | ||
38 | ); | ||
39 | diagnostic1.source = 'rustc'; | ||
40 | |||
41 | const diagnostic2 = new vscode.Diagnostic( | ||
42 | range1, | ||
43 | 'Hello, world!', | ||
44 | vscode.DiagnosticSeverity.Error, | ||
45 | ); | ||
46 | diagnostic2.source = 'clippy'; | ||
47 | |||
48 | assert(!areDiagnosticsEqual(diagnostic1, diagnostic2)); | ||
49 | }); | ||
50 | |||
51 | it('should treat diagnostics with different ranges as inequal', () => { | ||
52 | const diagnostic1 = new vscode.Diagnostic( | ||
53 | range1, | ||
54 | 'Hello, world!', | ||
55 | vscode.DiagnosticSeverity.Error, | ||
56 | ); | ||
57 | |||
58 | const diagnostic2 = new vscode.Diagnostic( | ||
59 | range2, | ||
60 | 'Hello, world!', | ||
61 | vscode.DiagnosticSeverity.Error, | ||
62 | ); | ||
63 | |||
64 | assert(!areDiagnosticsEqual(diagnostic1, diagnostic2)); | ||
65 | }); | ||
66 | |||
67 | it('should treat diagnostics with different messages as inequal', () => { | ||
68 | const diagnostic1 = new vscode.Diagnostic( | ||
69 | range1, | ||
70 | 'Hello, world!', | ||
71 | vscode.DiagnosticSeverity.Error, | ||
72 | ); | ||
73 | |||
74 | const diagnostic2 = new vscode.Diagnostic( | ||
75 | range1, | ||
76 | 'Goodbye!, world!', | ||
77 | vscode.DiagnosticSeverity.Error, | ||
78 | ); | ||
79 | |||
80 | assert(!areDiagnosticsEqual(diagnostic1, diagnostic2)); | ||
81 | }); | ||
82 | |||
83 | it('should treat diagnostics with different severities as inequal', () => { | ||
84 | const diagnostic1 = new vscode.Diagnostic( | ||
85 | range1, | ||
86 | 'Hello, world!', | ||
87 | vscode.DiagnosticSeverity.Warning, | ||
88 | ); | ||
89 | |||
90 | const diagnostic2 = new vscode.Diagnostic( | ||
91 | range1, | ||
92 | 'Hello, world!', | ||
93 | vscode.DiagnosticSeverity.Error, | ||
94 | ); | ||
95 | |||
96 | assert(!areDiagnosticsEqual(diagnostic1, diagnostic2)); | ||
97 | }); | ||
98 | }); | ||