OLD | NEW |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
| 5 @TestOn('vm') |
5 library code_transformers.test.resolver_test; | 6 library code_transformers.test.resolver_test; |
6 | 7 |
7 import 'dart:async'; | 8 import 'dart:async'; |
8 | 9 |
9 import 'package:barback/barback.dart'; | 10 import 'package:barback/barback.dart'; |
10 import 'package:code_transformers/resolver.dart'; | 11 import 'package:code_transformers/resolver.dart'; |
11 import 'package:code_transformers/tests.dart'; | 12 import 'package:transformer_test/utils.dart'; |
12 import 'package:unittest/compact_vm_config.dart'; | 13 import 'package:test/test.dart'; |
13 import 'package:unittest/unittest.dart'; | |
14 | 14 |
15 import 'package:code_transformers/src/dart_sdk.dart' show mockSdkSources; | 15 import 'package:code_transformers/src/dart_sdk.dart' show mockSdkSources; |
16 | 16 |
17 main() { | 17 main() { |
18 useCompactVMConfiguration(); | |
19 group('mock sdk', () { | 18 group('mock sdk', () { |
20 resolverTests(new Resolvers.fromMock(mockSdkSources)); | 19 resolverTests(new Resolvers.fromMock(mockSdkSources)); |
21 }); | 20 }); |
22 | 21 |
23 group('real sdk', () { | 22 group('real sdk', () { |
24 resolverTests(new Resolvers(testingDartSdkDirectory)); | 23 resolverTests(new Resolvers(testingDartSdkDirectory)); |
25 }); | 24 }); |
| 25 |
| 26 group('shared sources', () { |
| 27 resolverTests(new Resolvers.fromMock(mockSdkSources)); |
| 28 }); |
26 } | 29 } |
27 | 30 |
28 resolverTests(Resolvers resolvers) { | 31 resolverTests(Resolvers resolvers) { |
29 var entryPoint = new AssetId('a', 'web/main.dart'); | 32 var entryPoint = new AssetId('a', 'web/main.dart'); |
30 Future validateResolver({Map<String, String> inputs, validator(Resolver), | 33 Future validateResolver( |
31 List<String> messages: const []}) { | 34 {Map<String, String> inputs, |
32 return applyTransformers( | 35 validator(Resolver), |
33 [[new TestTransformer(resolvers, entryPoint, validator)]], | 36 List<String> messages: const [], |
34 inputs: inputs, messages: messages); | 37 bool resolveAllLibraries: true}) { |
| 38 return applyTransformers([ |
| 39 [ |
| 40 new TestTransformer( |
| 41 resolvers, entryPoint, validator, resolveAllLibraries) |
| 42 ] |
| 43 ], inputs: inputs, messages: messages); |
35 } | 44 } |
36 | 45 |
37 group('Resolver', () { | 46 group('Resolver', () { |
38 test('should handle initial files', () { | 47 test('should handle initial files', () { |
39 return validateResolver( | 48 return validateResolver( |
40 inputs: {'a|web/main.dart': ' main() {}',}, validator: (resolver) { | 49 inputs: { |
41 var source = resolver.sources[entryPoint]; | 50 'a|web/main.dart': ' main() {}', |
42 expect(source.modificationStamp, 1); | 51 }, |
43 | 52 validator: (resolver) { |
44 var lib = resolver.getLibrary(entryPoint); | 53 var source = resolver.sources[entryPoint]; |
45 expect(lib, isNotNull); | 54 expect(source.modificationStamp, 1); |
46 }); | 55 |
| 56 var lib = resolver.getLibrary(entryPoint); |
| 57 expect(lib, isNotNull); |
| 58 }); |
47 }); | 59 }); |
48 | 60 |
49 test('should update when sources change', () { | 61 test('should update when sources change', () { |
50 return validateResolver(inputs: { | 62 return validateResolver( |
51 'a|web/main.dart': ''' main() { | 63 inputs: { |
| 64 'a|web/main.dart': ''' main() { |
52 } ''', | 65 } ''', |
53 }, validator: (resolver) { | 66 }, |
54 var source = resolver.sources[entryPoint]; | 67 validator: (resolver) { |
55 expect(source.modificationStamp, 2); | 68 var source = resolver.sources[entryPoint]; |
56 | 69 expect(source.modificationStamp, 2); |
57 var lib = resolver.getLibrary(entryPoint); | 70 |
58 expect(lib, isNotNull); | 71 var lib = resolver.getLibrary(entryPoint); |
59 expect(lib.entryPoint, isNotNull); | 72 expect(lib, isNotNull); |
60 }); | 73 expect(lib.entryPoint, isNotNull); |
| 74 }); |
61 }); | 75 }); |
62 | 76 |
63 test('should follow imports', () { | 77 test('should follow imports', () { |
64 return validateResolver(inputs: { | 78 return validateResolver( |
65 'a|web/main.dart': ''' | 79 inputs: { |
| 80 'a|web/main.dart': ''' |
66 import 'a.dart'; | 81 import 'a.dart'; |
67 | 82 |
68 main() { | 83 main() { |
69 } ''', | 84 } ''', |
70 'a|web/a.dart': ''' | 85 'a|web/a.dart': ''' |
71 library a; | 86 library a; |
72 ''', | 87 ''', |
73 }, validator: (resolver) { | 88 }, |
74 var lib = resolver.getLibrary(entryPoint); | 89 validator: (resolver) { |
75 expect(lib.importedLibraries.length, 2); | 90 var lib = resolver.getLibrary(entryPoint); |
76 var libA = lib.importedLibraries.where((l) => l.name == 'a').single; | 91 expect(lib.importedLibraries.length, 2); |
77 expect(libA.getType('Foo'), isNull); | 92 var libA = lib.importedLibraries.where((l) => l.name == 'a').single; |
78 }); | 93 expect(libA.getType('Foo'), isNull); |
| 94 }); |
79 }); | 95 }); |
80 | 96 |
81 test('should update changed imports', () { | 97 test('should update changed imports', () { |
82 return validateResolver(inputs: { | 98 return validateResolver( |
83 'a|web/main.dart': ''' | 99 inputs: { |
| 100 'a|web/main.dart': ''' |
84 import 'a.dart'; | 101 import 'a.dart'; |
85 | 102 |
86 main() { | 103 main() { |
87 } ''', | 104 } ''', |
88 'a|web/a.dart': ''' | 105 'a|web/a.dart': ''' |
89 library a; | 106 library a; |
90 class Foo {} | 107 class Foo {} |
91 ''', | 108 ''', |
92 }, validator: (resolver) { | 109 }, |
93 var lib = resolver.getLibrary(entryPoint); | 110 validator: (resolver) { |
94 expect(lib.importedLibraries.length, 2); | 111 var lib = resolver.getLibrary(entryPoint); |
95 var libA = lib.importedLibraries.where((l) => l.name == 'a').single; | 112 expect(lib.importedLibraries.length, 2); |
96 expect(libA.getType('Foo'), isNotNull); | 113 var libA = lib.importedLibraries.where((l) => l.name == 'a').single; |
97 }); | 114 expect(libA.getType('Foo'), isNotNull); |
| 115 }); |
98 }); | 116 }); |
99 | 117 |
100 test('should follow package imports', () { | 118 test('should follow package imports', () { |
101 return validateResolver(inputs: { | 119 return validateResolver( |
102 'a|web/main.dart': ''' | 120 inputs: { |
| 121 'a|web/main.dart': ''' |
103 import 'package:b/b.dart'; | 122 import 'package:b/b.dart'; |
104 | 123 |
105 main() { | 124 main() { |
106 } ''', | 125 } ''', |
107 'b|lib/b.dart': ''' | 126 'b|lib/b.dart': ''' |
108 library b; | 127 library b; |
109 ''', | 128 ''', |
110 }, validator: (resolver) { | 129 }, |
111 var lib = resolver.getLibrary(entryPoint); | 130 validator: (resolver) { |
112 expect(lib.importedLibraries.length, 2); | 131 var lib = resolver.getLibrary(entryPoint); |
113 var libB = lib.importedLibraries.where((l) => l.name == 'b').single; | 132 expect(lib.importedLibraries.length, 2); |
114 expect(libB.getType('Foo'), isNull); | 133 var libB = lib.importedLibraries.where((l) => l.name == 'b').single; |
115 }); | 134 expect(libB.getType('Foo'), isNull); |
| 135 }); |
116 }); | 136 }); |
117 | 137 |
118 test('handles missing files', () { | 138 test('handles missing files', () { |
119 return validateResolver(inputs: { | 139 return validateResolver( |
120 'a|web/main.dart': ''' | 140 inputs: { |
| 141 'a|web/main.dart': ''' |
121 import 'package:b/missing.dart'; | 142 import 'package:b/missing.dart'; |
122 | 143 |
123 main() { | 144 main() { |
124 } ''', | 145 } ''', |
125 }, validator: (resolver) { | 146 }, |
126 var lib = resolver.getLibrary(entryPoint); | 147 validator: (resolver) { |
127 expect(lib.importedLibraries.length, 1); | 148 var lib = resolver.getLibrary(entryPoint); |
128 }); | 149 expect(lib.importedLibraries.length, 2); |
| 150 }); |
129 }); | 151 }); |
130 | 152 |
131 test('should update on changed package imports', () { | 153 test('should update on changed package imports', () { |
132 // TODO(sigmund): remove modification below, see dartbug.com/22638 | 154 // TODO(sigmund): remove modification below, see dartbug.com/22638 |
133 return validateResolver(inputs: { | 155 return validateResolver( |
134 'a|web/main.dart': ''' | 156 inputs: { |
| 157 'a|web/main.dart': ''' |
135 import 'package:b/missing.dart'; | 158 import 'package:b/missing.dart'; |
136 | 159 |
137 main() { | 160 main() { |
138 } // modified, but we shouldn't need to! ''', | 161 } // modified, but we shouldn't need to! ''', |
139 'b|lib/missing.dart': ''' | 162 'b|lib/missing.dart': ''' |
140 library b; | 163 library b; |
141 class Bar {} | 164 class Bar {} |
142 ''', | 165 ''', |
143 }, validator: (resolver) { | 166 }, |
144 var lib = resolver.getLibrary(entryPoint); | 167 validator: (resolver) { |
145 expect(lib.importedLibraries.length, 2); | 168 var lib = resolver.getLibrary(entryPoint); |
146 var libB = lib.importedLibraries.where((l) => l.name == 'b').single; | 169 expect(lib.importedLibraries.length, 2); |
147 expect(libB.getType('Bar'), isNotNull); | 170 var libB = lib.importedLibraries.where((l) => l.name == 'b').single; |
148 }); | 171 expect(libB.getType('Bar'), isNotNull); |
| 172 }); |
149 }); | 173 }); |
150 | 174 |
151 test('should handle deleted files', () { | 175 test('should handle deleted files', () { |
152 return validateResolver(inputs: { | 176 return validateResolver( |
153 'a|web/main.dart': ''' | 177 inputs: { |
| 178 'a|web/main.dart': ''' |
154 import 'package:b/missing.dart'; | 179 import 'package:b/missing.dart'; |
155 | 180 |
156 main() { | 181 main() { |
157 } ''', | 182 } ''', |
158 }, validator: (resolver) { | 183 }, |
159 var lib = resolver.getLibrary(entryPoint); | 184 validator: (resolver) { |
160 expect(lib.importedLibraries.length, 1); | 185 var lib = resolver.getLibrary(entryPoint); |
161 }); | 186 expect(lib.importedLibraries.length, 2); |
| 187 expect(lib.importedLibraries.where((l) => l.name == 'b'), isEmpty); |
| 188 }); |
162 }); | 189 }); |
163 | 190 |
164 test('should fail on absolute URIs', () { | 191 test('should fail on absolute URIs', () { |
165 var warningPrefix = 'warning: absolute paths not allowed'; | 192 var warningPrefix = 'warning: absolute paths not allowed'; |
166 return validateResolver(inputs: { | 193 return validateResolver( |
167 'a|web/main.dart': ''' | 194 inputs: { |
| 195 'a|web/main.dart': ''' |
168 import '/b.dart'; | 196 import '/b.dart'; |
169 | 197 |
170 main() { | 198 main() { |
171 } ''', | 199 } ''', |
172 }, messages: [ | 200 }, |
173 // First from the AST walker | 201 messages: [ |
174 '$warningPrefix: "/b.dart" (web/main.dart 0 14)', | 202 // First from the AST walker |
175 '$warningPrefix: "/b.dart"', | 203 '$warningPrefix: "/b.dart" (web/main.dart 0 14)', |
176 ], validator: (resolver) { | 204 ], |
177 var lib = resolver.getLibrary(entryPoint); | 205 validator: (resolver) { |
178 expect(lib.importedLibraries.length, 1); | 206 var lib = resolver.getLibrary(entryPoint); |
179 }); | 207 expect(lib.importedLibraries.length, 2); |
| 208 }); |
180 }); | 209 }); |
181 | 210 |
182 test('should list all libraries', () { | 211 test('should list all libraries', () { |
183 return validateResolver(inputs: { | 212 return validateResolver( |
184 'a|web/main.dart': ''' | 213 inputs: { |
| 214 'a|web/main.dart': ''' |
185 library a.main; | 215 library a.main; |
186 import 'package:a/a.dart'; | 216 import 'package:a/a.dart'; |
187 import 'package:a/b.dart'; | 217 import 'package:a/b.dart'; |
188 export 'package:a/d.dart'; | 218 export 'package:a/d.dart'; |
189 ''', | 219 ''', |
190 'a|lib/a.dart': 'library a.a;\n import "package:a/c.dart";', | 220 'a|lib/a.dart': 'library a.a;\n import "package:a/c.dart";', |
191 'a|lib/b.dart': 'library a.b;\n import "c.dart";', | 221 'a|lib/b.dart': 'library a.b;\n import "c.dart";', |
192 'a|lib/c.dart': 'library a.c;', | 222 'a|lib/c.dart': 'library a.c;', |
193 'a|lib/d.dart': 'library a.d;' | 223 'a|lib/d.dart': 'library a.d;' |
194 }, validator: (resolver) { | 224 }, |
195 var libs = resolver.libraries.where((l) => !l.isInSdk); | 225 validator: (resolver) { |
196 expect(libs.map((l) => l.name), | 226 var libs = resolver.libraries.where((l) => !l.isInSdk); |
197 unorderedEquals(['a.main', 'a.a', 'a.b', 'a.c', 'a.d',])); | 227 expect( |
198 }); | 228 libs.map((l) => l.name), |
| 229 unorderedEquals([ |
| 230 'a.main', |
| 231 'a.a', |
| 232 'a.b', |
| 233 'a.c', |
| 234 'a.d', |
| 235 ])); |
| 236 }); |
199 }); | 237 }); |
200 | 238 |
201 test('should resolve types and library uris', () { | 239 test('should resolve types and library uris', () { |
202 return validateResolver(inputs: { | 240 return validateResolver( |
203 'a|web/main.dart': ''' | 241 inputs: { |
| 242 'a|web/main.dart': ''' |
204 import 'dart:core'; | 243 import 'dart:core'; |
205 import 'package:a/a.dart'; | 244 import 'package:a/a.dart'; |
206 import 'package:a/b.dart'; | 245 import 'package:a/b.dart'; |
207 import 'sub_dir/d.dart'; | 246 import 'sub_dir/d.dart'; |
208 class Foo {} | 247 class Foo {} |
209 ''', | 248 ''', |
210 'a|lib/a.dart': 'library a.a;\n import "package:a/c.dart";', | 249 'a|lib/a.dart': 'library a.a;\n import "package:a/c.dart";', |
211 'a|lib/b.dart': 'library a.b;\n import "c.dart";', | 250 'a|lib/b.dart': 'library a.b;\n import "c.dart";', |
212 'a|lib/c.dart': ''' | 251 'a|lib/c.dart': ''' |
213 library a.c; | 252 library a.c; |
214 class Bar {} | 253 class Bar {} |
215 ''', | 254 ''', |
216 'a|web/sub_dir/d.dart': ''' | 255 'a|web/sub_dir/d.dart': ''' |
217 library a.web.sub_dir.d; | 256 library a.web.sub_dir.d; |
218 class Baz{} | 257 class Baz{} |
219 ''', | 258 ''', |
220 }, validator: (resolver) { | 259 }, |
221 var a = resolver.getLibraryByName('a.a'); | 260 validator: (resolver) { |
222 expect(a, isNotNull); | 261 var a = resolver.getLibraryByName('a.a'); |
223 expect(resolver.getImportUri(a).toString(), 'package:a/a.dart'); | 262 expect(a, isNotNull); |
224 expect(resolver.getLibraryByUri(Uri.parse('package:a/a.dart')), a); | 263 expect(resolver.getImportUri(a).toString(), 'package:a/a.dart'); |
225 | 264 expect(resolver.getLibraryByUri(Uri.parse('package:a/a.dart')), a); |
226 var main = resolver.getLibraryByName(''); | 265 |
227 expect(main, isNotNull); | 266 var main = resolver.getLibraryByName(''); |
228 expect(resolver.getImportUri(main), isNull); | 267 expect(main, isNotNull); |
229 | 268 expect(resolver.getImportUri(main), isNull); |
230 var fooType = resolver.getType('Foo'); | 269 |
231 expect(fooType, isNotNull); | 270 var fooType = resolver.getType('Foo'); |
232 expect(fooType.library, main); | 271 expect(fooType, isNotNull); |
233 | 272 expect(fooType.library, main); |
234 var barType = resolver.getType('a.c.Bar'); | 273 |
235 expect(barType, isNotNull); | 274 var barType = resolver.getType('a.c.Bar'); |
236 expect(resolver.getImportUri(barType.library).toString(), | 275 expect(barType, isNotNull); |
237 'package:a/c.dart'); | 276 expect(resolver.getImportUri(barType.library).toString(), |
238 expect( | 277 'package:a/c.dart'); |
239 resolver.getSourceAssetId(barType), new AssetId('a', 'lib/c.dart')); | 278 expect(resolver.getSourceAssetId(barType), |
240 | 279 new AssetId('a', 'lib/c.dart')); |
241 var bazType = resolver.getType('a.web.sub_dir.d.Baz'); | 280 |
242 expect(bazType, isNotNull); | 281 var bazType = resolver.getType('a.web.sub_dir.d.Baz'); |
243 expect(resolver.getImportUri(bazType.library), isNull); | 282 expect(bazType, isNotNull); |
244 expect( | 283 expect(resolver.getImportUri(bazType.library), isNull); |
245 resolver.getImportUri(bazType.library, from: entryPoint).toString(), | 284 expect( |
246 'sub_dir/d.dart'); | 285 resolver |
247 | 286 .getImportUri(bazType.library, from: entryPoint) |
248 var hashMap = resolver.getType('dart.collection.HashMap'); | 287 .toString(), |
249 expect(resolver.getImportUri(hashMap.library).toString(), | 288 'sub_dir/d.dart'); |
250 'dart:collection'); | 289 |
251 expect(resolver.getLibraryByUri(Uri.parse('dart:collection')), | 290 var hashMap = resolver.getType('dart.collection.HashMap'); |
252 hashMap.library); | 291 expect(resolver.getImportUri(hashMap.library).toString(), |
253 }); | 292 'dart:collection'); |
| 293 expect(resolver.getLibraryByUri(Uri.parse('dart:collection')), |
| 294 hashMap.library); |
| 295 }); |
| 296 }); |
| 297 |
| 298 test('should resolve constants in transitive imports by default', () { |
| 299 return validateResolver( |
| 300 inputs: { |
| 301 'a|web/main.dart': ''' |
| 302 library web.main; |
| 303 |
| 304 import 'package:a/do_resolve.dart'; |
| 305 export 'package:a/do_resolve.dart'; |
| 306 |
| 307 class Foo extends Bar {} |
| 308 ''', |
| 309 'a|lib/do_resolve.dart': ''' |
| 310 library a.do_resolve; |
| 311 |
| 312 const int annotation = 0; |
| 313 @annotation |
| 314 class Bar {}''', |
| 315 }, |
| 316 validator: (resolver) { |
| 317 var main = resolver.getLibraryByName('web.main'); |
| 318 // Navigate to the library via Element models |
| 319 var meta = |
| 320 main.unit.declarations[0].element.supertype.element.metadata[0]; |
| 321 expect(meta, isNotNull); |
| 322 expect(meta.constantValue, isNotNull); |
| 323 |
| 324 // Get the library from the resolver directly |
| 325 var lib = resolver.getLibraryByName('a.do_resolve'); |
| 326 meta = lib.unit.declarations[1].element.metadata[0]; |
| 327 expect(meta, isNotNull); |
| 328 expect(meta.constantValue, isNotNull); |
| 329 }); |
| 330 }); |
| 331 |
| 332 test('can disable resolving of constants in transitive imports', () { |
| 333 return validateResolver( |
| 334 resolveAllLibraries: false, |
| 335 inputs: { |
| 336 'a|web/main.dart': ''' |
| 337 library web.main; |
| 338 |
| 339 import 'package:a/dont_resolve.dart'; |
| 340 export 'package:a/dont_resolve.dart'; |
| 341 |
| 342 class Foo extends Bar {} |
| 343 ''', |
| 344 'a|lib/dont_resolve.dart': ''' |
| 345 library a.dont_resolve; |
| 346 |
| 347 const int annotation = 0; |
| 348 @annotation |
| 349 class Bar {}''', |
| 350 }, |
| 351 validator: (resolver) { |
| 352 var main = resolver.getLibraryByName('web.main'); |
| 353 var meta = |
| 354 main.unit.declarations[0].element.supertype.element.metadata[0]; |
| 355 expect(meta, isNotNull); |
| 356 expect(meta.constantValue, isNull); |
| 357 }); |
254 }); | 358 }); |
255 | 359 |
256 test('deleted files should be removed', () { | 360 test('deleted files should be removed', () { |
257 return validateResolver( | 361 return validateResolver( |
258 inputs: { | 362 inputs: { |
259 'a|web/main.dart': '''import 'package:a/a.dart';''', | 363 'a|web/main.dart': '''import 'package:a/a.dart';''', |
260 'a|lib/a.dart': '''import 'package:a/b.dart';''', | 364 'a|lib/a.dart': '''import 'package:a/b.dart';''', |
261 'a|lib/b.dart': '''class Engine{}''', | 365 'a|lib/b.dart': '''class Engine{}''', |
262 }, | 366 }, |
263 validator: (resolver) { | 367 validator: (resolver) { |
264 var engine = resolver.getType('Engine'); | 368 var engine = resolver.getType('Engine'); |
265 var uri = resolver.getImportUri(engine.library); | 369 var uri = resolver.getImportUri(engine.library); |
266 expect(uri.toString(), 'package:a/b.dart'); | 370 expect(uri.toString(), 'package:a/b.dart'); |
267 }).then((_) { | 371 }).then((_) { |
268 return validateResolver( | 372 return validateResolver( |
269 inputs: { | 373 inputs: { |
270 'a|web/main.dart': '''import 'package:a/a.dart';''', | 374 'a|web/main.dart': '''import 'package:a/a.dart';''', |
271 'a|lib/a.dart': '''lib a;\n class Engine{}''' | 375 'a|lib/a.dart': '''lib a;\n class Engine{}''' |
272 }, | 376 }, |
273 validator: (resolver) { | 377 validator: (resolver) { |
274 var engine = resolver.getType('Engine'); | 378 var engine = resolver.getType('Engine'); |
275 var uri = resolver.getImportUri(engine.library); | 379 var uri = resolver.getImportUri(engine.library); |
276 expect(uri.toString(), 'package:a/a.dart'); | 380 expect(uri.toString(), 'package:a/a.dart'); |
277 | 381 |
278 // Make sure that we haven't leaked any sources. | 382 // Make sure that we haven't leaked any sources. |
279 expect(resolver.sources.length, 2); | 383 expect(resolver.sources.length, 2); |
280 }); | 384 }); |
281 }); | 385 }); |
282 }); | 386 }); |
283 | 387 |
284 test('handles circular imports', () { | 388 test('handles circular imports', () { |
285 return validateResolver(inputs: { | 389 return validateResolver( |
286 'a|web/main.dart': ''' | 390 inputs: { |
| 391 'a|web/main.dart': ''' |
287 library main; | 392 library main; |
288 import 'package:a/a.dart'; ''', | 393 import 'package:a/a.dart'; ''', |
289 'a|lib/a.dart': ''' | 394 'a|lib/a.dart': ''' |
290 library a; | 395 library a; |
291 import 'package:a/b.dart'; ''', | 396 import 'package:a/b.dart'; ''', |
292 'a|lib/b.dart': ''' | 397 'a|lib/b.dart': ''' |
293 library b; | 398 library b; |
294 import 'package:a/a.dart'; ''', | 399 import 'package:a/a.dart'; ''', |
295 }, validator: (resolver) { | 400 }, |
296 var libs = resolver.libraries.map((lib) => lib.name); | 401 validator: (resolver) { |
297 expect(libs.contains('a'), isTrue); | 402 var libs = resolver.libraries.map((lib) => lib.name); |
298 expect(libs.contains('b'), isTrue); | 403 expect(libs.contains('a'), isTrue); |
299 }); | 404 expect(libs.contains('b'), isTrue); |
| 405 }); |
300 }); | 406 }); |
301 | 407 |
302 test('handles parallel resolves', () { | 408 test('handles parallel resolves', () { |
303 return Future.wait([ | 409 return Future.wait([ |
304 validateResolver(inputs: { | 410 validateResolver( |
305 'a|web/main.dart': ''' | 411 inputs: { |
| 412 'a|web/main.dart': ''' |
306 library foo;''' | 413 library foo;''' |
307 }, validator: (resolver) { | 414 }, |
308 expect(resolver.getLibrary(entryPoint).name, 'foo'); | 415 validator: (resolver) { |
309 }), | 416 expect(resolver.getLibrary(entryPoint).name, 'foo'); |
310 validateResolver(inputs: { | 417 }), |
311 'a|web/main.dart': ''' | 418 validateResolver( |
| 419 inputs: { |
| 420 'a|web/main.dart': ''' |
312 library bar;''' | 421 library bar;''' |
313 }, validator: (resolver) { | 422 }, |
314 expect(resolver.getLibrary(entryPoint).name, 'bar'); | 423 validator: (resolver) { |
315 }), | 424 expect(resolver.getLibrary(entryPoint).name, 'bar'); |
| 425 }), |
316 ]); | 426 ]); |
317 }); | 427 }); |
318 }); | 428 }); |
319 } | 429 } |
320 | 430 |
321 class TestTransformer extends Transformer with ResolverTransformer { | 431 class TestTransformer extends Transformer with ResolverTransformer { |
322 final AssetId primary; | 432 final AssetId primary; |
323 final Function validator; | 433 final Function validator; |
| 434 final bool resolveAllLibraries; |
324 | 435 |
325 TestTransformer(Resolvers resolvers, this.primary, this.validator) { | 436 TestTransformer(Resolvers resolvers, this.primary, this.validator, |
| 437 this.resolveAllLibraries) { |
326 this.resolvers = resolvers; | 438 this.resolvers = resolvers; |
327 } | 439 } |
328 | 440 |
329 // TODO(nweiz): This should just take an AssetId when barback <0.13.0 support | 441 // TODO(nweiz): This should just take an AssetId when barback <0.13.0 support |
330 // is dropped. | 442 // is dropped. |
331 Future<bool> isPrimary(idOrAsset) { | 443 Future<bool> isPrimary(idOrAsset) { |
332 var id = idOrAsset is AssetId ? idOrAsset : idOrAsset.id; | 444 var id = idOrAsset is AssetId ? idOrAsset : (idOrAsset as Asset).id; |
333 return new Future.value(id == primary); | 445 return new Future.value(id == primary); |
334 } | 446 } |
335 | 447 |
336 applyResolver(Transform transform, Resolver resolver) => validator(resolver); | 448 applyResolver(Transform transform, Resolver resolver) => validator(resolver); |
337 } | 449 } |
OLD | NEW |