OLD | NEW |
| (Empty) |
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | |
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. | |
4 | |
5 library polymer.test.build.polymer_smoke_generator_test; | |
6 | |
7 import 'package:code_transformers/tests.dart' | |
8 show testingDartSdkDirectory, StringFormatter; | |
9 import 'package:polymer/src/build/common.dart'; | |
10 import 'package:polymer/src/build/messages.dart'; | |
11 import 'package:polymer/src/build/polymer_smoke_generator.dart'; | |
12 import 'package:smoke/codegen/generator.dart' show DEFAULT_IMPORTS; | |
13 import 'package:unittest/compact_vm_config.dart'; | |
14 import 'package:unittest/unittest.dart'; | |
15 | |
16 import 'common.dart'; | |
17 | |
18 void main() { | |
19 useCompactVMConfiguration(); | |
20 var phases = [ | |
21 [ | |
22 new PolymerSmokeGeneratorTransformer(new TransformOptions(), | |
23 sdkDir: testingDartSdkDirectory) | |
24 ] | |
25 ]; | |
26 group('initializers', () => initializerTests(phases)); | |
27 group('codegen', () => codegenTests(phases)); | |
28 group('log element injection', logElementInjectionTests); | |
29 } | |
30 | |
31 initializerTests(phases) { | |
32 testPhases('no changes', phases, { | |
33 'a|web/test.html': '<!DOCTYPE html><html></html>', | |
34 }, {'a|web/test.html': '<!DOCTYPE html><html></html>',}); | |
35 | |
36 testPhases('no changes outside web/', phases, { | |
37 'a|lib/test.html': '<!DOCTYPE html><html><head>' | |
38 '<script type="application/dart" src="a.dart"></script>', | |
39 }, { | |
40 'a|lib/test.html': '<!DOCTYPE html><html><head>' | |
41 '<script type="application/dart" src="a.dart"></script>', | |
42 }); | |
43 | |
44 testPhases('single script', phases, { | |
45 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
46 '<script type="application/dart" src="a.dart"></script>', | |
47 'a|web/a.dart': 'library a;\n' | |
48 'import "package:polymer/polymer.dart";\n' | |
49 'main(){}', | |
50 }, { | |
51 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
52 '<script type="application/dart" src="test.html_bootstrap.dart">' | |
53 '</script>' | |
54 '</head><body></body></html>', | |
55 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
56 import 'a.dart' as i0; | |
57 ${DEFAULT_IMPORTS.join('\n')} | |
58 import 'package:polymer/polymer.dart' as smoke_0; | |
59 | |
60 main() { | |
61 useGeneratedCode(new StaticConfiguration( | |
62 checkedMode: false, | |
63 declarations: { | |
64 smoke_0.PolymerElement: {}, | |
65 })); | |
66 configureForDeployment(); | |
67 return i0.main(); | |
68 } | |
69 '''.replaceAll('\n ', '\n'), | |
70 'a|web/a.dart': 'library a;\n' | |
71 'import "package:polymer/polymer.dart";\n' | |
72 'main(){}', | |
73 }); | |
74 | |
75 testPhases('simple initialization', phases, { | |
76 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
77 '<script type="application/dart" src="a.dart"></script>', | |
78 'a|web/a.dart': 'library a;\n' | |
79 'import "package:polymer/polymer.dart";\n' | |
80 '@CustomTag("x-foo")\n' | |
81 'class XFoo extends PolymerElement {\n' | |
82 '}\n' | |
83 'main(){}', | |
84 }, { | |
85 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
86 import 'a.dart' as i0; | |
87 ${DEFAULT_IMPORTS.join('\n')} | |
88 import 'package:polymer/polymer.dart' as smoke_0; | |
89 import 'a.dart' as smoke_1; | |
90 | |
91 main() { | |
92 useGeneratedCode(new StaticConfiguration( | |
93 checkedMode: false, | |
94 parents: { | |
95 smoke_1.XFoo: smoke_0.PolymerElement, | |
96 }, | |
97 declarations: { | |
98 smoke_1.XFoo: {}, | |
99 smoke_0.PolymerElement: {}, | |
100 })); | |
101 configureForDeployment(); | |
102 return i0.main(); | |
103 } | |
104 '''.replaceAll('\n ', '\n'), | |
105 }); | |
106 | |
107 testPhases('simple initialization of imports and exports', phases, { | |
108 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
109 '<script type="application/dart" src="a.dart"></script>', | |
110 'a|web/a.dart': ''' | |
111 library a; | |
112 import "package:polymer/polymer.dart"; | |
113 import 'b.dart'; | |
114 | |
115 @CustomTag("x-a") | |
116 class XA extends PolymerElement {} | |
117 main(){}'''.replaceAll('\n ', '\n'), | |
118 'a|web/b.dart': ''' | |
119 library b; | |
120 import "package:polymer/polymer.dart"; | |
121 export 'c.dart'; | |
122 | |
123 @CustomTag("x-b") | |
124 class XB extends PolymerElement {} | |
125 ''', | |
126 'a|web/c.dart': ''' | |
127 library c; | |
128 import "package:polymer/polymer.dart"; | |
129 | |
130 @CustomTag("x-c") | |
131 class XC extends PolymerElement {} | |
132 ''', | |
133 }, { | |
134 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
135 import 'a.dart' as i0; | |
136 ${DEFAULT_IMPORTS.join('\n')} | |
137 import 'package:polymer/polymer.dart' as smoke_0; | |
138 import 'c.dart' as smoke_1; | |
139 import 'b.dart' as smoke_2; | |
140 import 'a.dart' as smoke_3; | |
141 | |
142 main() { | |
143 useGeneratedCode(new StaticConfiguration( | |
144 checkedMode: false, | |
145 parents: { | |
146 smoke_3.XA: smoke_0.PolymerElement, | |
147 smoke_2.XB: smoke_0.PolymerElement, | |
148 smoke_1.XC: smoke_0.PolymerElement, | |
149 }, | |
150 declarations: { | |
151 smoke_3.XA: {}, | |
152 smoke_2.XB: {}, | |
153 smoke_1.XC: {}, | |
154 smoke_0.PolymerElement: {}, | |
155 })); | |
156 configureForDeployment(); | |
157 return i0.main(); | |
158 } | |
159 '''.replaceAll('\n ', '\n'), | |
160 }); | |
161 | |
162 testPhases('use const expressions', phases, { | |
163 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
164 '<script type="application/dart" src="a.dart"></script>', | |
165 'a|web/b.dart': 'library a;\n' | |
166 'const x = "x";\n', | |
167 'a|web/c.dart': 'part of a;\n' | |
168 'const dash = "-";\n', | |
169 'a|web/a.dart': 'library a;\n' | |
170 'import "package:polymer/polymer.dart";\n' | |
171 'import "b.dart";\n' | |
172 'part "c.dart";\n' | |
173 'const letterO = "o";\n' | |
174 '@CustomTag("\$x\${dash}f\${letterO}o2")\n' | |
175 'class XFoo extends PolymerElement {\n' | |
176 '}\n', | |
177 }, { | |
178 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
179 import 'a.dart' as i0; | |
180 ${DEFAULT_IMPORTS.join('\n')} | |
181 import 'package:polymer/polymer.dart' as smoke_0; | |
182 import 'a.dart' as smoke_1; | |
183 | |
184 main() { | |
185 useGeneratedCode(new StaticConfiguration( | |
186 checkedMode: false, | |
187 parents: { | |
188 smoke_1.XFoo: smoke_0.PolymerElement, | |
189 }, | |
190 declarations: { | |
191 smoke_1.XFoo: {}, | |
192 smoke_0.PolymerElement: {}, | |
193 })); | |
194 configureForDeployment(); | |
195 return i0.main(); | |
196 } | |
197 '''.replaceAll('\n ', '\n'), | |
198 }); | |
199 | |
200 testLogOutput((options) => new PolymerSmokeGeneratorTransformer(options, | |
201 sdkDir: testingDartSdkDirectory), 'invalid const expression logs', { | |
202 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
203 '<script type="application/dart" src="a.dart"></script>', | |
204 'a|web/a.dart': 'library a;\n' | |
205 'import "package:polymer/polymer.dart";\n' | |
206 '@CustomTag("\${x}-foo")\n' // invalid, x is not defined | |
207 'class XFoo extends PolymerElement {\n' | |
208 '}\n' | |
209 'main(){}', | |
210 }, {}, [ | |
211 'warning: ${INVALID_ANNOTATION_ARGUMENT.create( | |
212 {'name': 'CustomTag'}).snippet} (web/a.dart 2 11)', | |
213 ]); | |
214 | |
215 testPhases('invalid const expression', phases, { | |
216 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
217 '<script type="application/dart" src="a.dart"></script>', | |
218 'a|web/a.dart': 'library a;\n' | |
219 'import "package:polymer/polymer.dart";\n' | |
220 '@CustomTag("\${x}-foo")\n' // invalid, x is not defined | |
221 'class XFoo extends PolymerElement {\n' | |
222 '}\n' | |
223 'main(){}', | |
224 }, { | |
225 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
226 import 'a.dart' as i0; | |
227 ${DEFAULT_IMPORTS.join('\n')} | |
228 import 'package:polymer/polymer.dart' as smoke_0; | |
229 import 'a.dart' as smoke_1; | |
230 | |
231 main() { | |
232 useGeneratedCode(new StaticConfiguration( | |
233 checkedMode: false, | |
234 parents: { | |
235 smoke_1.XFoo: smoke_0.PolymerElement, | |
236 }, | |
237 declarations: { | |
238 smoke_1.XFoo: {}, | |
239 smoke_0.PolymerElement: {}, | |
240 })); | |
241 configureForDeployment(); | |
242 return i0.main(); | |
243 } | |
244 '''.replaceAll('\n ', '\n'), | |
245 }); | |
246 | |
247 testPhases('no polymer import (warning, but no crash)', phases, { | |
248 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
249 '<script type="application/dart" src="a.dart"></script>', | |
250 'a|web/a.dart': 'library a;\n' | |
251 'import "package:polymer/polymer.broken.import.dart";\n' | |
252 '@CustomTag("x-foo")\n' | |
253 'class XFoo extends PolymerElement {\n' | |
254 '}\n' | |
255 'main(){}', | |
256 }, { | |
257 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
258 '<script type="application/dart" src="test.html_bootstrap.dart">' | |
259 '</script></head><body></body></html>', | |
260 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
261 import 'a.dart' as i0; | |
262 ${DEFAULT_IMPORTS.join('\n')} | |
263 | |
264 main() { | |
265 useGeneratedCode(new StaticConfiguration( | |
266 checkedMode: false)); | |
267 configureForDeployment(); | |
268 return i0.main(); | |
269 } | |
270 '''.replaceAll('\n ', '\n'), | |
271 }, ['warning: ${MISSING_POLYMER_DART.snippet}']); | |
272 } | |
273 | |
274 codegenTests(phases) { | |
275 testPhases('bindings', phases, { | |
276 'a|web/test.html': '<!DOCTYPE html><html>' | |
277 '<head>' | |
278 '<link rel="import" href="foo_remote.html">' | |
279 '</head><body>' | |
280 '<polymer-element name="foo-bar"><template>' | |
281 '<div>{{a.node}}</div>' | |
282 '<div>{{ anotherNode }}</div>' // extra space inside bindings is OK | |
283 '<div>{{a.call1(a)}}</div>' | |
284 '<div>{{call2(a)}}</div>' | |
285 '<div>{{}}</div>' // empty bindings are ignored | |
286 '<div>{{ }}</div>' | |
287 '<div class="{{an.attribute}}"></div>' | |
288 '<a href="path/{{within.an.attribute}}/foo/bar"></a>' | |
289 '<div data-attribute="{{anotherAttribute}}"></div>' | |
290 // input and custom-element attributes are treated as 2-way bindings: | |
291 '<input value="{{this.iS.twoWay}}">' | |
292 '<input value="{{this.iS.twoWayInt | intToStringTransformer}}">' | |
293 '<something-else my-attribute="{{here.too}}"></something-else>' | |
294 '<div on-click="{{methodName}}"></div>' | |
295 '<div on-click="{{ methodName2 }}"></div>' // extra space is OK | |
296 // empty handlers are invalid, but we still produce valid output. | |
297 '<div on-click="{{}}"></div>' | |
298 '<div on-click="{{ }}"></div>' | |
299 '</template></polymer-element>' | |
300 '<script type="application/dart" src="a.dart"></script>', | |
301 'a|web/foo_remote.html': '<polymer-element name="foo-remote"><template>' | |
302 '<div>{{remoteValue}}</div>' | |
303 '</template></polymer-element>', | |
304 'a|web/a.dart': 'library a;\n' | |
305 'import "package:polymer/polymer.dart";\n' | |
306 'main(){}', | |
307 }, { | |
308 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
309 import 'a.dart' as i0; | |
310 ${DEFAULT_IMPORTS.join('\n')} | |
311 import 'package:polymer/polymer.dart' as smoke_0; | |
312 | |
313 main() { | |
314 useGeneratedCode(new StaticConfiguration( | |
315 checkedMode: false, | |
316 getters: { | |
317 #a: (o) => o.a, | |
318 #an: (o) => o.an, | |
319 #anotherAttribute: (o) => o.anotherAttribute, | |
320 #anotherNode: (o) => o.anotherNode, | |
321 #attribute: (o) => o.attribute, | |
322 #call1: (o) => o.call1, | |
323 #call2: (o) => o.call2, | |
324 #here: (o) => o.here, | |
325 #iS: (o) => o.iS, | |
326 #intToStringTransformer: (o) => o.intToStringTransformer, | |
327 #methodName: (o) => o.methodName, | |
328 #methodName2: (o) => o.methodName2, | |
329 #node: (o) => o.node, | |
330 #remoteValue: (o) => o.remoteValue, | |
331 #too: (o) => o.too, | |
332 #twoWay: (o) => o.twoWay, | |
333 #twoWayInt: (o) => o.twoWayInt, | |
334 #within: (o) => o.within, | |
335 }, | |
336 setters: { | |
337 #too: (o, v) { o.too = v; }, | |
338 #twoWay: (o, v) { o.twoWay = v; }, | |
339 #twoWayInt: (o, v) { o.twoWayInt = v; }, | |
340 }, | |
341 declarations: { | |
342 smoke_0.PolymerElement: {}, | |
343 }, | |
344 names: { | |
345 #a: r'a', | |
346 #an: r'an', | |
347 #anotherAttribute: r'anotherAttribute', | |
348 #anotherNode: r'anotherNode', | |
349 #attribute: r'attribute', | |
350 #call1: r'call1', | |
351 #call2: r'call2', | |
352 #here: r'here', | |
353 #iS: r'iS', | |
354 #intToStringTransformer: r'intToStringTransformer', | |
355 #methodName: r'methodName', | |
356 #methodName2: r'methodName2', | |
357 #node: r'node', | |
358 #remoteValue: r'remoteValue', | |
359 #too: r'too', | |
360 #twoWay: r'twoWay', | |
361 #twoWayInt: r'twoWayInt', | |
362 #within: r'within', | |
363 })); | |
364 configureForDeployment(); | |
365 return i0.main(); | |
366 } | |
367 '''.replaceAll('\n ', '\n'), | |
368 }); | |
369 | |
370 computedDeclaration(name, expr) => | |
371 '#$name: const Declaration(#$name, Object, kind: PROPERTY,' | |
372 ' isFinal: true, annotations: const [const smoke_0.ComputedProperty' | |
373 '(\'$expr\')])'; | |
374 | |
375 testPhases('computed properties', phases, { | |
376 'a|web/test.html': '<!DOCTYPE html><html><body>' | |
377 '<polymer-element name="x-foo"><template>' | |
378 '</template></polymer-element>' | |
379 '<script type="application/dart" src="a.dart"></script>', | |
380 'a|web/a.dart': 'library a;\n' | |
381 'import "package:polymer/polymer.dart";\n' | |
382 '@CustomTag("x-foo")\n' | |
383 'class XFoo extends PolymerElement {\n' | |
384 ' @ComputedProperty("ta.tb")\n' | |
385 ' get pa => readValue(#pa);\n' | |
386 ' @ComputedProperty(" tc ")\n' // extra space inside is OK | |
387 ' get pb => null;\n' | |
388 ' @ComputedProperty("td.m1(te)")\n' | |
389 ' get pc => null;\n' | |
390 ' @ComputedProperty("m2(tf)")\n' | |
391 ' get pd => null;\n' | |
392 ' @ComputedProperty("")\n' // empty is ignored | |
393 ' get pe => null;\n' | |
394 ' @ComputedProperty(" ")\n' | |
395 ' get pf => null;\n' | |
396 ' @ComputedProperty("tg + th")\n' | |
397 ' get pg => null;\n' | |
398 ' @ComputedProperty("ti.tj | tk")\n' | |
399 ' get ph => null;\n' | |
400 '}\n' | |
401 'main(){}', | |
402 }, { | |
403 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
404 import 'a.dart' as i0; | |
405 ${DEFAULT_IMPORTS.join('\n')} | |
406 import 'package:polymer/polymer.dart' as smoke_0; | |
407 import 'a.dart' as smoke_1; | |
408 | |
409 main() { | |
410 useGeneratedCode(new StaticConfiguration( | |
411 checkedMode: false, | |
412 getters: { | |
413 #m1: (o) => o.m1, | |
414 #m2: (o) => o.m2, | |
415 #pa: (o) => o.pa, | |
416 #pb: (o) => o.pb, | |
417 #pc: (o) => o.pc, | |
418 #pd: (o) => o.pd, | |
419 #pe: (o) => o.pe, | |
420 #pf: (o) => o.pf, | |
421 #pg: (o) => o.pg, | |
422 #ph: (o) => o.ph, | |
423 #ta: (o) => o.ta, | |
424 #tb: (o) => o.tb, | |
425 #tc: (o) => o.tc, | |
426 #td: (o) => o.td, | |
427 #te: (o) => o.te, | |
428 #tf: (o) => o.tf, | |
429 #tg: (o) => o.tg, | |
430 #th: (o) => o.th, | |
431 #ti: (o) => o.ti, | |
432 #tj: (o) => o.tj, | |
433 #tk: (o) => o.tk, | |
434 }, | |
435 setters: { | |
436 #tb: (o, v) { o.tb = v; }, | |
437 #tc: (o, v) { o.tc = v; }, | |
438 #tj: (o, v) { o.tj = v; }, | |
439 }, | |
440 parents: { | |
441 smoke_1.XFoo: smoke_0.PolymerElement, | |
442 }, | |
443 declarations: { | |
444 smoke_1.XFoo: { | |
445 ${computedDeclaration('pa', 'ta.tb')}, | |
446 ${computedDeclaration('pb', ' tc ')}, | |
447 ${computedDeclaration('pc', 'td.m1(te)')}, | |
448 ${computedDeclaration('pd', 'm2(tf)')}, | |
449 ${computedDeclaration('pe', '')}, | |
450 ${computedDeclaration('pf', ' ')}, | |
451 ${computedDeclaration('pg', 'tg + th')}, | |
452 ${computedDeclaration('ph', 'ti.tj | tk')}, | |
453 }, | |
454 smoke_0.PolymerElement: {}, | |
455 }, | |
456 names: { | |
457 #m1: r'm1', | |
458 #m2: r'm2', | |
459 #pa: r'pa', | |
460 #pb: r'pb', | |
461 #pc: r'pc', | |
462 #pd: r'pd', | |
463 #pe: r'pe', | |
464 #pf: r'pf', | |
465 #pg: r'pg', | |
466 #ph: r'ph', | |
467 #ta: r'ta', | |
468 #tb: r'tb', | |
469 #tc: r'tc', | |
470 #td: r'td', | |
471 #te: r'te', | |
472 #tf: r'tf', | |
473 #tg: r'tg', | |
474 #th: r'th', | |
475 #ti: r'ti', | |
476 #tj: r'tj', | |
477 #tk: r'tk', | |
478 })); | |
479 configureForDeployment(); | |
480 return i0.main(); | |
481 } | |
482 '''.replaceAll('\n ', '\n'), | |
483 }); | |
484 | |
485 final field1Details = "annotations: const [smoke_0.published]"; | |
486 final field3Details = "isFinal: true, annotations: const [smoke_0.published]"; | |
487 final prop1Details = "kind: PROPERTY, annotations: const [smoke_0.published]"; | |
488 final prop3Details = | |
489 "kind: PROPERTY, isFinal: true, annotations: const [smoke_0.published]"; | |
490 testPhases('published via annotation', phases, { | |
491 'a|web/test.html': '<!DOCTYPE html><html><body>' | |
492 '<script type="application/dart" src="a.dart"></script>', | |
493 'a|web/a.dart': 'library a;\n' | |
494 'import "package:polymer/polymer.dart";\n' | |
495 '@CustomTag("x-foo")\n' | |
496 'class XFoo extends PolymerElement {\n' | |
497 ' @published int field1;\n' | |
498 ' int field2;\n' | |
499 ' @published final int field3;\n' | |
500 ' final int field4;\n' | |
501 ' @published int get prop1 => 1;\n' | |
502 ' set prop1(int x) {};\n' | |
503 ' int get prop2 => 2;\n' | |
504 ' set prop2(int x) {};\n' | |
505 ' @published int get prop3 => 3;\n' | |
506 ' int get prop4 => 4;\n' | |
507 ' @published int method1() => 1;\n' | |
508 ' int method2() => 2;\n' | |
509 '}\n', | |
510 }, { | |
511 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
512 import 'a.dart' as i0; | |
513 ${DEFAULT_IMPORTS.join('\n')} | |
514 import 'package:polymer/polymer.dart' as smoke_0; | |
515 import 'a.dart' as smoke_1; | |
516 | |
517 main() { | |
518 useGeneratedCode(new StaticConfiguration( | |
519 checkedMode: false, | |
520 getters: { | |
521 #field1: (o) => o.field1, | |
522 #field3: (o) => o.field3, | |
523 #prop1: (o) => o.prop1, | |
524 #prop3: (o) => o.prop3, | |
525 }, | |
526 setters: { | |
527 #field1: (o, v) { o.field1 = v; }, | |
528 #prop1: (o, v) { o.prop1 = v; }, | |
529 }, | |
530 parents: { | |
531 smoke_1.XFoo: smoke_0.PolymerElement, | |
532 }, | |
533 declarations: { | |
534 smoke_1.XFoo: { | |
535 #field1: const Declaration(#field1, int, $field1Details), | |
536 #field3: const Declaration(#field3, int, $field3Details), | |
537 #prop1: const Declaration(#prop1, int, $prop1Details), | |
538 #prop3: const Declaration(#prop3, int, $prop3Details), | |
539 }, | |
540 smoke_0.PolymerElement: {}, | |
541 }, | |
542 names: { | |
543 #field1: r'field1', | |
544 #field3: r'field3', | |
545 #prop1: r'prop1', | |
546 #prop3: r'prop3', | |
547 })); | |
548 configureForDeployment(); | |
549 return i0.main(); | |
550 } | |
551 '''.replaceAll('\n ', '\n'), | |
552 }); | |
553 | |
554 testPhases('published via attributes', phases, { | |
555 'a|web/test.html': '<!DOCTYPE html><html><body>' | |
556 '<polymer-element name="x-foo" attributes="field1,prop2">' | |
557 '</polymer-element>' | |
558 '<script type="application/dart" src="a.dart"></script>', | |
559 'a|web/a.dart': 'library a;\n' | |
560 'import "package:polymer/polymer.dart";\n' | |
561 '@CustomTag("x-foo")\n' | |
562 'class XFoo extends PolymerElement {\n' | |
563 ' int field1;\n' | |
564 ' int field2;\n' | |
565 ' int get prop1 => 1;\n' | |
566 ' set prop1(int x) {};\n' | |
567 ' int get prop2 => 2;\n' | |
568 ' set prop2(int x) {};\n' | |
569 '}\n', | |
570 }, { | |
571 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
572 import 'a.dart' as i0; | |
573 ${DEFAULT_IMPORTS.join('\n')} | |
574 import 'package:polymer/polymer.dart' as smoke_0; | |
575 import 'a.dart' as smoke_1; | |
576 | |
577 main() { | |
578 useGeneratedCode(new StaticConfiguration( | |
579 checkedMode: false, | |
580 getters: { | |
581 #field1: (o) => o.field1, | |
582 #prop2: (o) => o.prop2, | |
583 }, | |
584 setters: { | |
585 #field1: (o, v) { o.field1 = v; }, | |
586 #prop2: (o, v) { o.prop2 = v; }, | |
587 }, | |
588 parents: { | |
589 smoke_1.XFoo: smoke_0.PolymerElement, | |
590 }, | |
591 declarations: { | |
592 smoke_1.XFoo: { | |
593 #field1: const Declaration(#field1, int), | |
594 #prop2: const Declaration(#prop2, int, kind: PROPERTY), | |
595 }, | |
596 smoke_0.PolymerElement: {}, | |
597 }, | |
598 names: { | |
599 #field1: r'field1', | |
600 #prop2: r'prop2', | |
601 })); | |
602 configureForDeployment(); | |
603 return i0.main(); | |
604 } | |
605 '''.replaceAll('\n ', '\n'), | |
606 }); | |
607 | |
608 final fooDetails = | |
609 "kind: METHOD, annotations: const [const smoke_0.ObserveProperty('x')]"; | |
610 final xChangedDetails = "Function, kind: METHOD"; | |
611 testPhases('ObserveProperty and *Changed methods', phases, { | |
612 'a|web/test.html': '<!DOCTYPE html><html><body>' | |
613 '</polymer-element>' | |
614 '<script type="application/dart" src="a.dart"></script>', | |
615 'a|web/a.dart': 'library a;\n' | |
616 'import "package:polymer/polymer.dart";\n' | |
617 '@CustomTag("x-foo")\n' | |
618 'class XFoo extends PolymerElement {\n' | |
619 ' int x;\n' | |
620 ' void xChanged() {}\n' | |
621 ' void attributeChanged() {}\n' // should be excluded | |
622 ' @ObserveProperty("x")' | |
623 ' void foo() {}\n' | |
624 '}\n', | |
625 }, { | |
626 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
627 import 'a.dart' as i0; | |
628 ${DEFAULT_IMPORTS.join('\n')} | |
629 import 'package:polymer/polymer.dart' as smoke_0; | |
630 import 'a.dart' as smoke_1; | |
631 | |
632 main() { | |
633 useGeneratedCode(new StaticConfiguration( | |
634 checkedMode: false, | |
635 getters: { | |
636 #foo: (o) => o.foo, | |
637 #xChanged: (o) => o.xChanged, | |
638 }, | |
639 parents: { | |
640 smoke_1.XFoo: smoke_0.PolymerElement, | |
641 }, | |
642 declarations: { | |
643 smoke_1.XFoo: { | |
644 #foo: const Declaration(#foo, Function, $fooDetails), | |
645 #xChanged: const Declaration(#xChanged, $xChangedDetails), | |
646 }, | |
647 smoke_0.PolymerElement: {}, | |
648 }, | |
649 names: { | |
650 #foo: r'foo', | |
651 #xChanged: r'xChanged', | |
652 })); | |
653 configureForDeployment(); | |
654 return i0.main(); | |
655 } | |
656 '''.replaceAll('\n ', '\n'), | |
657 }); | |
658 | |
659 final rcDetails = "#registerCallback, Function, kind: METHOD, isStatic: true"; | |
660 testPhases('register callback is included', phases, { | |
661 'a|web/test.html': '<!DOCTYPE html><html><body>' | |
662 '</polymer-element>' | |
663 '<script type="application/dart" src="a.dart"></script>', | |
664 'a|web/a.dart': 'library a;\n' | |
665 'import "package:polymer/polymer.dart";\n' | |
666 '@CustomTag("x-foo")\n' | |
667 'class XFoo extends PolymerElement {\n' | |
668 ' static registerCallback() {};\n' | |
669 ' static foo() {};\n' | |
670 '}\n', | |
671 }, { | |
672 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
673 import 'a.dart' as i0; | |
674 ${DEFAULT_IMPORTS.join('\n')} | |
675 import 'package:polymer/polymer.dart' as smoke_0; | |
676 import 'a.dart' as smoke_1; | |
677 | |
678 main() { | |
679 useGeneratedCode(new StaticConfiguration( | |
680 checkedMode: false, | |
681 parents: { | |
682 smoke_1.XFoo: smoke_0.PolymerElement, | |
683 }, | |
684 declarations: { | |
685 smoke_1.XFoo: { | |
686 #registerCallback: const Declaration($rcDetails), | |
687 }, | |
688 smoke_0.PolymerElement: {}, | |
689 }, | |
690 staticMethods: { | |
691 smoke_1.XFoo: { | |
692 #registerCallback: smoke_1.XFoo.registerCallback, | |
693 }, | |
694 }, | |
695 names: { | |
696 #registerCallback: r'registerCallback', | |
697 })); | |
698 configureForDeployment(); | |
699 return i0.main(); | |
700 } | |
701 '''.replaceAll('\n ', '\n'), | |
702 }); | |
703 } | |
704 | |
705 void logElementInjectionTests() { | |
706 final outputLogsPhases = [ | |
707 [ | |
708 new PolymerSmokeGeneratorTransformer(new TransformOptions( | |
709 injectBuildLogsInOutput: true, releaseMode: false), | |
710 sdkDir: testingDartSdkDirectory) | |
711 ] | |
712 ]; | |
713 | |
714 testPhases('Injects logging element and styles', outputLogsPhases, { | |
715 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
716 '<script type="application/dart" src="a.dart"></script>', | |
717 'a|web/a.dart': 'library a;\n' | |
718 'import "package:polymer/polymer.dart";\n' | |
719 'main(){}', | |
720 }, { | |
721 'a|web/test.html': '<!DOCTYPE html><html><head>' | |
722 '<script type="application/dart" ' | |
723 'src="test.html_bootstrap.dart"></script>' | |
724 '<link rel="stylesheet" type="text/css" ' | |
725 'href="packages/polymer/src/build/log_injector.css">' | |
726 '</head><body>' | |
727 '</body></html>', | |
728 'a|web/test.html_bootstrap.dart': '''$MAIN_HEADER | |
729 import 'package:polymer/src/build/log_injector.dart'; | |
730 import 'a.dart' as i0; | |
731 ${DEFAULT_IMPORTS.join('\n')} | |
732 import 'package:polymer/polymer.dart' as smoke_0; | |
733 | |
734 main() { | |
735 useGeneratedCode(new StaticConfiguration( | |
736 checkedMode: false, | |
737 declarations: { | |
738 smoke_0.PolymerElement: {}, | |
739 })); | |
740 new LogInjector().injectLogsFromUrl('test.html._buildLogs'); | |
741 configureForDeployment(); | |
742 return i0.main(); | |
743 } | |
744 '''.replaceAll('\n ', '\n'), | |
745 'a|web/a.dart': 'library a;\n' | |
746 'import "package:polymer/polymer.dart";\n' | |
747 'main(){}', | |
748 }); | |
749 } | |
OLD | NEW |