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 test.domain.analysis.notification.overrides; |
| 6 |
| 7 import 'dart:async'; |
| 8 |
| 9 import 'package:analysis_server/src/analysis_server.dart'; |
| 10 import 'package:analysis_server/src/computer/computer_overrides.dart'; |
| 11 import 'package:analysis_server/src/computer/element.dart'; |
| 12 import 'package:analysis_server/src/constants.dart'; |
| 13 import 'package:analysis_server/src/protocol.dart'; |
| 14 import 'package:unittest/unittest.dart'; |
| 15 |
| 16 import 'analysis_abstract.dart'; |
| 17 import 'reflective_tests.dart'; |
| 18 |
| 19 |
| 20 main() { |
| 21 group('notification.occurrences', () { |
| 22 runReflectiveTests(AnalysisNotificationOverridesTest); |
| 23 }); |
| 24 } |
| 25 |
| 26 |
| 27 @ReflectiveTestCase() |
| 28 class AnalysisNotificationOverridesTest extends AbstractAnalysisTest { |
| 29 List<Override> overridesList; |
| 30 Override override; |
| 31 |
| 32 /** |
| 33 * Asserts that there is an overridden interface [Element] at the offset of |
| 34 * [search] in [override]. |
| 35 */ |
| 36 void assertHasInterfaceElement(String search) { |
| 37 int offset = findOffset(search); |
| 38 for (Element element in override.interfaceElements) { |
| 39 if (element.location.offset == offset) { |
| 40 return; |
| 41 } |
| 42 } |
| 43 fail('Expect to find an overridden interface elements at $offset in ' |
| 44 '${override.interfaceElements.join('\n')}'); |
| 45 } |
| 46 |
| 47 /** |
| 48 * Validates that there is an [Override] at the offset of [search]. |
| 49 * |
| 50 * If [length] is not specified explicitly, then length of an identifier |
| 51 * from [search] is used. |
| 52 */ |
| 53 void assertHasOverride(String search, [int length = -1]) { |
| 54 int offset = findOffset(search); |
| 55 if (length == -1) { |
| 56 length = findIdentifierLength(search); |
| 57 } |
| 58 findOverride(offset, length, true); |
| 59 } |
| 60 |
| 61 /** |
| 62 * Asserts that there is an overridden superclass [Element] at the offset of |
| 63 * [search] in [override]. |
| 64 */ |
| 65 void assertHasSuperElement(String search) { |
| 66 int offset = findOffset(search); |
| 67 Element element = override.superclassElement; |
| 68 expect(element.location.offset, offset); |
| 69 } |
| 70 |
| 71 /** |
| 72 * Asserts that there are no overridden elements from interfaces. |
| 73 */ |
| 74 void assertNoInterfaceElements() { |
| 75 expect(override.interfaceElements, isNull); |
| 76 } |
| 77 |
| 78 /** |
| 79 * Asserts that there are no overridden elements from the superclass. |
| 80 */ |
| 81 void assertNoSuperElement() { |
| 82 expect(override.superclassElement, isNull); |
| 83 } |
| 84 |
| 85 /** |
| 86 * Finds an [Override] with the given [offset] and [length]. |
| 87 * |
| 88 * If [exists] is `true`, then fails if such [Override] does not exist. |
| 89 * Otherwise remembers this it into [override]. |
| 90 * |
| 91 * If [exists] is `false`, then fails if such [Override] exists. |
| 92 */ |
| 93 void findOverride(int offset, int length, [bool exists]) { |
| 94 for (Override override in overridesList) { |
| 95 if (override.offset == offset && override.length == length) { |
| 96 if (exists == false) { |
| 97 fail('Not expected to find (offset=$offset; length=$length) in\n' |
| 98 '${overridesList.join('\n')}'); |
| 99 } |
| 100 this.override = override; |
| 101 return; |
| 102 } |
| 103 } |
| 104 if (exists == true) { |
| 105 fail('Expected to find (offset=$offset; length=$length) in\n' |
| 106 '${overridesList.join('\n')}'); |
| 107 } |
| 108 } |
| 109 |
| 110 Future prepareOverrides(then()) { |
| 111 addAnalysisSubscription(AnalysisService.OVERRIDES, testFile); |
| 112 return waitForTasksFinished().then((_) { |
| 113 then(); |
| 114 }); |
| 115 } |
| 116 |
| 117 void processNotification(Notification notification) { |
| 118 if (notification.event == ANALYSIS_OVERRIDES) { |
| 119 String file = notification.getParameter(FILE); |
| 120 if (file == testFile) { |
| 121 overridesList = <Override>[]; |
| 122 List<Map<String, Object>> jsonList = notification.getParameter( |
| 123 OVERRIDES); |
| 124 for (Map<String, Object> json in jsonList) { |
| 125 overridesList.add(new Override.fromJson(json)); |
| 126 } |
| 127 } |
| 128 } |
| 129 } |
| 130 |
| 131 void setUp() { |
| 132 super.setUp(); |
| 133 createProject(); |
| 134 } |
| 135 |
| 136 test_afterAnalysis() { |
| 137 addTestFile(''' |
| 138 class A { |
| 139 m() {} // in A |
| 140 } |
| 141 class B implements A { |
| 142 m() {} // in B |
| 143 } |
| 144 '''); |
| 145 return waitForTasksFinished().then((_) { |
| 146 return prepareOverrides(() { |
| 147 assertHasOverride('m() {} // in B'); |
| 148 assertNoSuperElement(); |
| 149 assertHasInterfaceElement('m() {} // in A'); |
| 150 }); |
| 151 }); |
| 152 } |
| 153 |
| 154 test_interface_method_direct_multiple() { |
| 155 addTestFile(''' |
| 156 class IA { |
| 157 m() {} // in IA |
| 158 } |
| 159 class IB { |
| 160 m() {} // in IB |
| 161 } |
| 162 class A implements IA, IB { |
| 163 m() {} // in A |
| 164 } |
| 165 '''); |
| 166 return prepareOverrides(() { |
| 167 assertHasOverride('m() {} // in A'); |
| 168 assertNoSuperElement(); |
| 169 assertHasInterfaceElement('m() {} // in IA'); |
| 170 assertHasInterfaceElement('m() {} // in IB'); |
| 171 }); |
| 172 } |
| 173 |
| 174 test_interface_method_direct_single() { |
| 175 addTestFile(''' |
| 176 class A { |
| 177 m() {} // in A |
| 178 } |
| 179 class B implements A { |
| 180 m() {} // in B |
| 181 } |
| 182 '''); |
| 183 return prepareOverrides(() { |
| 184 assertHasOverride('m() {} // in B'); |
| 185 assertNoSuperElement(); |
| 186 assertHasInterfaceElement('m() {} // in A'); |
| 187 }); |
| 188 } |
| 189 |
| 190 test_interface_method_indirect_single() { |
| 191 addTestFile(''' |
| 192 class A { |
| 193 m() {} // in A |
| 194 } |
| 195 class B extends A { |
| 196 } |
| 197 class C implements B { |
| 198 m() {} // in C |
| 199 } |
| 200 '''); |
| 201 return prepareOverrides(() { |
| 202 assertHasOverride('m() {} // in C'); |
| 203 assertNoSuperElement(); |
| 204 assertHasInterfaceElement('m() {} // in A'); |
| 205 }); |
| 206 } |
| 207 |
| 208 test_super_fieldByField() { |
| 209 addTestFile(''' |
| 210 class A { |
| 211 int fff; // in A |
| 212 } |
| 213 class B extends A { |
| 214 int fff; // in B |
| 215 } |
| 216 '''); |
| 217 return prepareOverrides(() { |
| 218 assertHasOverride('fff; // in B'); |
| 219 assertHasSuperElement('fff; // in A'); |
| 220 assertNoInterfaceElements(); |
| 221 }); |
| 222 } |
| 223 |
| 224 test_super_fieldByGetter() { |
| 225 addTestFile(''' |
| 226 class A { |
| 227 int fff; // in A |
| 228 } |
| 229 class B extends A { |
| 230 get fff => 0; // in B |
| 231 } |
| 232 '''); |
| 233 return prepareOverrides(() { |
| 234 assertHasOverride('fff => 0; // in B'); |
| 235 assertHasSuperElement('fff; // in A'); |
| 236 assertNoInterfaceElements(); |
| 237 }); |
| 238 } |
| 239 |
| 240 test_super_fieldByMethod() { |
| 241 addTestFile(''' |
| 242 class A { |
| 243 int fff; // in A |
| 244 } |
| 245 class B extends A { |
| 246 fff() {} // in B |
| 247 } |
| 248 '''); |
| 249 return prepareOverrides(() { |
| 250 assertHasOverride('fff() {} // in B'); |
| 251 assertHasSuperElement('fff; // in A'); |
| 252 assertNoInterfaceElements(); |
| 253 }); |
| 254 } |
| 255 |
| 256 test_super_fieldBySetter() { |
| 257 addTestFile(''' |
| 258 class A { |
| 259 int fff; // in A |
| 260 } |
| 261 class B extends A { |
| 262 set fff(x) {} // in B |
| 263 } |
| 264 '''); |
| 265 return prepareOverrides(() { |
| 266 assertHasOverride('fff(x) {} // in B'); |
| 267 assertHasSuperElement('fff; // in A'); |
| 268 assertNoInterfaceElements(); |
| 269 }); |
| 270 } |
| 271 |
| 272 test_super_getterByField() { |
| 273 addTestFile(''' |
| 274 class A { |
| 275 get fff => 0; // in A |
| 276 set fff(x) {} // in A |
| 277 } |
| 278 class B extends A { |
| 279 int fff; // in B |
| 280 } |
| 281 '''); |
| 282 return prepareOverrides(() { |
| 283 assertHasOverride('fff; // in B'); |
| 284 assertHasSuperElement('fff => 0; // in A'); |
| 285 assertNoInterfaceElements(); |
| 286 }); |
| 287 } |
| 288 |
| 289 test_super_getterByGetter() { |
| 290 addTestFile(''' |
| 291 class A { |
| 292 get fff => 0; // in A |
| 293 } |
| 294 class B extends A { |
| 295 get fff => 0; // in B |
| 296 } |
| 297 '''); |
| 298 return prepareOverrides(() { |
| 299 assertHasOverride('fff => 0; // in B'); |
| 300 assertHasSuperElement('fff => 0; // in A'); |
| 301 assertNoInterfaceElements(); |
| 302 }); |
| 303 } |
| 304 |
| 305 test_super_method_direct() { |
| 306 addTestFile(''' |
| 307 class A { |
| 308 m() {} // in A |
| 309 } |
| 310 class B extends A { |
| 311 m() {} // in B |
| 312 } |
| 313 '''); |
| 314 return prepareOverrides(() { |
| 315 assertHasOverride('m() {} // in B'); |
| 316 assertHasSuperElement('m() {} // in A'); |
| 317 assertNoInterfaceElements(); |
| 318 }); |
| 319 } |
| 320 |
| 321 test_super_method_indirect() { |
| 322 addTestFile(''' |
| 323 class A { |
| 324 m() {} // in A |
| 325 } |
| 326 class B extends A { |
| 327 } |
| 328 class C extends B { |
| 329 m() {} // in C |
| 330 } |
| 331 '''); |
| 332 return prepareOverrides(() { |
| 333 assertHasOverride('m() {} // in C'); |
| 334 assertHasSuperElement('m() {} // in A'); |
| 335 assertNoInterfaceElements(); |
| 336 }); |
| 337 } |
| 338 |
| 339 test_super_setterBySetter() { |
| 340 addTestFile(''' |
| 341 class A { |
| 342 set fff(x) {} // in A |
| 343 } |
| 344 class B extends A { |
| 345 set fff(x) {} // in B |
| 346 } |
| 347 '''); |
| 348 return prepareOverrides(() { |
| 349 assertHasOverride('fff(x) {} // in B'); |
| 350 assertHasSuperElement('fff(x) {} // in A'); |
| 351 assertNoInterfaceElements(); |
| 352 }); |
| 353 } |
| 354 } |
OLD | NEW |