| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 library stub_core_libraries.test; | |
| 6 | |
| 7 import 'dart:io'; | |
| 8 | |
| 9 import 'package:path/path.dart' as p; | |
| 10 import 'package:stub_core_library/stub_core_library.dart'; | |
| 11 import 'package:unittest/unittest.dart'; | |
| 12 | |
| 13 String sandbox; | |
| 14 | |
| 15 main() { | |
| 16 setUp(() { | |
| 17 sandbox = Directory.systemTemp.createTempSync('stub_core_library_').path; | |
| 18 }); | |
| 19 | |
| 20 tearDown(() => new Directory(sandbox).deleteSync(recursive: true)); | |
| 21 | |
| 22 group("imports", () { | |
| 23 test("dart: imports are preserved by default", () { | |
| 24 expectStub(""" | |
| 25 import "dart:core"; | |
| 26 import "dart:html"; | |
| 27 import "dart:fblthp"; | |
| 28 """, """ | |
| 29 import "dart:core"; | |
| 30 import "dart:html"; | |
| 31 import "dart:fblthp"; | |
| 32 """); | |
| 33 }); | |
| 34 | |
| 35 test("internal dart: imports are removed", () { | |
| 36 expectStub(""" | |
| 37 import "dart:_internal"; | |
| 38 import "dart:_blink" as _blink; | |
| 39 import "dart:_fblthp"; | |
| 40 """, ""); | |
| 41 }); | |
| 42 | |
| 43 test("replaced imports are replaced", () { | |
| 44 expectStub(""" | |
| 45 import "dart:html"; | |
| 46 import "foo.dart" as foo; | |
| 47 """, """ | |
| 48 import "dart_html.dart"; | |
| 49 import "bar.dart" as foo; | |
| 50 """, { | |
| 51 "dart:html": "dart_html.dart", | |
| 52 "foo.dart": "bar.dart" | |
| 53 }); | |
| 54 }); | |
| 55 | |
| 56 test("exports are replaced as well", () { | |
| 57 expectStub(""" | |
| 58 export "dart:html"; | |
| 59 export "foo.dart" show foo; | |
| 60 """, """ | |
| 61 export "dart_html.dart"; | |
| 62 export "bar.dart" show foo; | |
| 63 """, { | |
| 64 "dart:html": "dart_html.dart", | |
| 65 "foo.dart": "bar.dart" | |
| 66 }); | |
| 67 }); | |
| 68 }); | |
| 69 | |
| 70 test("a parted file is stubbed and included inline", () { | |
| 71 new File(p.join(sandbox, "part.dart")).writeAsStringSync(""" | |
| 72 part of lib; | |
| 73 void foo() => print('foo!'); | |
| 74 """); | |
| 75 | |
| 76 expectStub(""" | |
| 77 library lib; | |
| 78 part "part.dart"; | |
| 79 """, """ | |
| 80 library lib; | |
| 81 void foo() { ${unsupported("foo()")}; } | |
| 82 """); | |
| 83 }); | |
| 84 | |
| 85 test("a class declaration's native clause is removed", () { | |
| 86 expectStub("class Foo native 'Foo' {}", "class Foo {}"); | |
| 87 }); | |
| 88 | |
| 89 group("constructors", () { | |
| 90 test("a constructor's body is stubbed out", () { | |
| 91 expectStub(""" | |
| 92 class Foo { | |
| 93 Foo() { print("Created a foo!"); } | |
| 94 } | |
| 95 """, """ | |
| 96 class Foo { | |
| 97 Foo() { ${unsupported("new Foo()")}; } | |
| 98 } | |
| 99 """); | |
| 100 }); | |
| 101 | |
| 102 test("a constructor's empty body is stubbed out", () { | |
| 103 expectStub("class Foo { Foo(); }", """ | |
| 104 class Foo { | |
| 105 Foo() { ${unsupported("new Foo()")}; } | |
| 106 } | |
| 107 """); | |
| 108 }); | |
| 109 | |
| 110 test("a constructor's external declaration is removed", () { | |
| 111 expectStub("class Foo { external Foo(); }", """ | |
| 112 class Foo { | |
| 113 Foo() { ${unsupported("new Foo()")}; } | |
| 114 } | |
| 115 """); | |
| 116 }); | |
| 117 | |
| 118 test("a constructor's field initializers are removed", () { | |
| 119 expectStub(""" | |
| 120 class Foo { | |
| 121 final _field1; | |
| 122 final _field2; | |
| 123 | |
| 124 Foo() | |
| 125 : _field1 = 1, | |
| 126 _field2 = 2; | |
| 127 } | |
| 128 """, """ | |
| 129 class Foo { | |
| 130 Foo() { ${unsupported("new Foo()")}; } | |
| 131 } | |
| 132 """); | |
| 133 }); | |
| 134 | |
| 135 test("a constructor's redirecting initializers are removed", () { | |
| 136 expectStub(""" | |
| 137 class Foo { | |
| 138 Foo() : this.create(); | |
| 139 Foo.create(); | |
| 140 } | |
| 141 """, """ | |
| 142 class Foo { | |
| 143 Foo() { ${unsupported("new Foo()")}; } | |
| 144 Foo.create() { ${unsupported("new Foo.create()")}; } | |
| 145 } | |
| 146 """); | |
| 147 }); | |
| 148 | |
| 149 test("a constructor's superclass calls are preserved", () { | |
| 150 expectStub(""" | |
| 151 class Foo { | |
| 152 Foo(int i, int j, {int k}); | |
| 153 } | |
| 154 | |
| 155 class Bar extends Foo { | |
| 156 Bar() : super(1, 2, k: 3); | |
| 157 } | |
| 158 """, """ | |
| 159 class Foo { | |
| 160 Foo(int i, int j, {int k}) { ${unsupported("new Foo()")}; } | |
| 161 } | |
| 162 | |
| 163 class Bar extends Foo { | |
| 164 Bar() | |
| 165 : super(${unsupported("new Bar()")}, null) { | |
| 166 ${unsupported("new Bar()")}; | |
| 167 } | |
| 168 } | |
| 169 """); | |
| 170 }); | |
| 171 | |
| 172 test("a constructor's initializing formals are replaced with normal " | |
| 173 "parameters", () { | |
| 174 expectStub(""" | |
| 175 class Foo { | |
| 176 final int _i; | |
| 177 var _j; | |
| 178 final List<int> _k; | |
| 179 | |
| 180 Foo(this._i, this._j, this._k); | |
| 181 } | |
| 182 """, """ | |
| 183 class Foo { | |
| 184 Foo(int _i, _j, List<int> _k) { ${unsupported("new Foo()")}; } | |
| 185 } | |
| 186 """); | |
| 187 }); | |
| 188 | |
| 189 test("a const constructor isn't stubbed", () { | |
| 190 expectStub("class Foo { const Foo(); }", "class Foo { const Foo(); }"); | |
| 191 }); | |
| 192 | |
| 193 test("a const constructor's superclass calls are fully preserved", () { | |
| 194 expectStub(""" | |
| 195 class Foo { | |
| 196 const Foo(int i, int j, int k); | |
| 197 } | |
| 198 | |
| 199 class Bar extends Foo { | |
| 200 const Bar() : super(1, 2, 3); | |
| 201 } | |
| 202 """, """ | |
| 203 class Foo { | |
| 204 const Foo(int i, int j, int k); | |
| 205 } | |
| 206 | |
| 207 class Bar extends Foo { | |
| 208 const Bar() : super(1, 2, 3); | |
| 209 } | |
| 210 """); | |
| 211 }); | |
| 212 | |
| 213 test("a redirecting const constructor stops redirecting", () { | |
| 214 expectStub(""" | |
| 215 class Foo { | |
| 216 const Foo.named(int i, int j, int k) | |
| 217 : this(i, j, k); | |
| 218 const Foo(int i, int j, int k); | |
| 219 } | |
| 220 """, """ | |
| 221 class Foo { | |
| 222 const Foo.named(int i, int j, int k); | |
| 223 const Foo(int i, int j, int k); | |
| 224 } | |
| 225 """); | |
| 226 }); | |
| 227 }); | |
| 228 | |
| 229 group("functions", () { | |
| 230 test("stubs a top-level function", () { | |
| 231 expectStub("void foo() => print('hello!');", | |
| 232 "void foo() { ${unsupported('foo()')}; }"); | |
| 233 }); | |
| 234 | |
| 235 test("stubs a private top-level function", () { | |
| 236 expectStub("void _foo() => print('hello!');", | |
| 237 "void _foo() { ${unsupported('_foo()')}; }"); | |
| 238 }); | |
| 239 | |
| 240 test("stubs a method", () { | |
| 241 expectStub(""" | |
| 242 class Foo { | |
| 243 foo() => print("hello!"); | |
| 244 } | |
| 245 """, """ | |
| 246 class Foo { | |
| 247 foo() { ${unsupported('Foo.foo()')}; } | |
| 248 } | |
| 249 """); | |
| 250 }); | |
| 251 | |
| 252 test("empties a method in an unconstructable class", () { | |
| 253 expectStub(""" | |
| 254 class Foo { | |
| 255 Foo(); | |
| 256 foo() => print("hello!"); | |
| 257 } | |
| 258 """, """ | |
| 259 class Foo { | |
| 260 Foo() { ${unsupported('new Foo()')}; } | |
| 261 foo() {} | |
| 262 } | |
| 263 """); | |
| 264 }); | |
| 265 | |
| 266 test("removes a private instance method", () { | |
| 267 expectStub(""" | |
| 268 class Foo { | |
| 269 _foo() => print("hello!"); | |
| 270 } | |
| 271 """, "class Foo {}"); | |
| 272 }); | |
| 273 | |
| 274 test("stubs a private static method", () { | |
| 275 expectStub(""" | |
| 276 class Foo { | |
| 277 static _foo() => print("hello!"); | |
| 278 } | |
| 279 """, """ | |
| 280 class Foo { | |
| 281 static _foo() { ${unsupported('Foo._foo()')}; } | |
| 282 } | |
| 283 """); | |
| 284 }); | |
| 285 | |
| 286 test("preserves an abstract instance method", () { | |
| 287 expectStub("abstract class Foo { foo(); }", | |
| 288 "abstract class Foo { foo(); }"); | |
| 289 }); | |
| 290 | |
| 291 test("removes a native function body", () { | |
| 292 expectStub("void foo() native 'foo';", | |
| 293 "void foo() { ${unsupported('foo()')}; }"); | |
| 294 }); | |
| 295 }); | |
| 296 | |
| 297 group("top-level fields", () { | |
| 298 test("stubs out a top-level field", () { | |
| 299 expectStub("int foo;", """ | |
| 300 int get foo => ${unsupported('foo')}; | |
| 301 set foo(int _) { ${unsupported('foo=')}; } | |
| 302 """); | |
| 303 }); | |
| 304 | |
| 305 test("stubs out a top-level field with a value", () { | |
| 306 expectStub("int foo = 12;", """ | |
| 307 int get foo => ${unsupported('foo')}; | |
| 308 set foo(int _) { ${unsupported('foo=')}; } | |
| 309 """); | |
| 310 }); | |
| 311 | |
| 312 test("stubs out a final top-level field", () { | |
| 313 expectStub("final int foo = 12;", | |
| 314 "int get foo => ${unsupported('foo')};"); | |
| 315 }); | |
| 316 | |
| 317 test("preserves a const top-level field", () { | |
| 318 expectStub("const foo = 12;", "const foo = 12;"); | |
| 319 }); | |
| 320 | |
| 321 test("removes a private top-level field", () { | |
| 322 expectStub("int _foo = 12;", ""); | |
| 323 }); | |
| 324 | |
| 325 test("preserves a private const top-level field", () { | |
| 326 expectStub("const _foo = 12;", "const _foo = 12;"); | |
| 327 }); | |
| 328 | |
| 329 test("splits a multiple-declaration top-level field", () { | |
| 330 expectStub("int foo, bar, baz;", """ | |
| 331 int get foo => ${unsupported('foo')}; | |
| 332 set foo(int _) { ${unsupported('foo=')}; } | |
| 333 int get bar => ${unsupported('bar')}; | |
| 334 set bar(int _) { ${unsupported('bar=')}; } | |
| 335 int get baz => ${unsupported('baz')}; | |
| 336 set baz(int _) { ${unsupported('baz=')}; } | |
| 337 """); | |
| 338 }); | |
| 339 }); | |
| 340 | |
| 341 group("instance fields", () { | |
| 342 test("stubs out an instance field", () { | |
| 343 expectStub("class Foo { int foo; }", """ | |
| 344 class Foo { | |
| 345 int get foo => ${unsupported('Foo.foo')}; | |
| 346 set foo(int _) { ${unsupported('Foo.foo=')}; } | |
| 347 } | |
| 348 """); | |
| 349 }); | |
| 350 | |
| 351 test("stubs out an instance field with a value", () { | |
| 352 expectStub("class Foo { int foo = 12; }", """ | |
| 353 class Foo { | |
| 354 int get foo => ${unsupported('Foo.foo')}; | |
| 355 set foo(int _) { ${unsupported('Foo.foo=')}; } | |
| 356 } | |
| 357 """); | |
| 358 }); | |
| 359 | |
| 360 test("stubs out a final instance field", () { | |
| 361 expectStub("class Foo { final int foo = 12; }", """ | |
| 362 class Foo { | |
| 363 int get foo => ${unsupported('Foo.foo')}; | |
| 364 } | |
| 365 """); | |
| 366 }); | |
| 367 | |
| 368 test("removes a private instance field", () { | |
| 369 expectStub("class Foo { int _foo = 12; }", "class Foo { }"); | |
| 370 }); | |
| 371 | |
| 372 test("stubs out a static instance field", () { | |
| 373 expectStub("class Foo { static int foo = 12; }", """ | |
| 374 class Foo { | |
| 375 static int get foo => ${unsupported('Foo.foo')}; | |
| 376 static set foo(int _) { ${unsupported('Foo.foo=')}; } | |
| 377 } | |
| 378 """); | |
| 379 }); | |
| 380 | |
| 381 test("removes a private static instance field", () { | |
| 382 expectStub("class Foo { static int _foo = 12; }", "class Foo { }"); | |
| 383 }); | |
| 384 | |
| 385 test("preserves a static const instance field", () { | |
| 386 expectStub("class Foo { static const foo = 12; }", | |
| 387 "class Foo { static const foo = 12; }"); | |
| 388 }); | |
| 389 | |
| 390 test("nulls a field for an unconstructable class", () { | |
| 391 expectStub(""" | |
| 392 class Foo { | |
| 393 Foo(); | |
| 394 final foo = 12; | |
| 395 } | |
| 396 """, """ | |
| 397 class Foo { | |
| 398 Foo() { ${unsupported("new Foo()")}; } | |
| 399 final foo = null; | |
| 400 } | |
| 401 """); | |
| 402 }); | |
| 403 | |
| 404 test("splits a multiple-declaration instance field", () { | |
| 405 expectStub("class Foo { int foo, bar, baz; }", """ | |
| 406 class Foo { | |
| 407 int get foo => ${unsupported('Foo.foo')}; | |
| 408 set foo(int _) { ${unsupported('Foo.foo=')}; } | |
| 409 int get bar => ${unsupported('Foo.bar')}; | |
| 410 set bar(int _) { ${unsupported('Foo.bar=')}; } | |
| 411 int get baz => ${unsupported('Foo.baz')}; | |
| 412 set baz(int _) { ${unsupported('Foo.baz=')}; } | |
| 413 } | |
| 414 """); | |
| 415 }); | |
| 416 }); | |
| 417 } | |
| 418 | |
| 419 /// Expects that [source] will transform into [expected] when stubbed. | |
| 420 void expectStub(String source, String expected, | |
| 421 [Map<String, String> importReplacements]) { | |
| 422 expect(stubCode(source, p.join(sandbox, 'source.dart'), importReplacements), | |
| 423 equalsIgnoringWhitespace(expected)); | |
| 424 } | |
| 425 | |
| 426 /// Returns code for throwing an [UnsupportedError] for the given name. | |
| 427 String unsupported(String name) => 'throw new UnsupportedError("$name is ' | |
| 428 'unsupported on this platform.")'; | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1134583005:
Remove the core library stubbing infrastructure. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart