mirror of
https://github.com/dart-lang/sdk
synced 2024-09-22 10:11:35 +00:00
03e379de7a
R=brianwilkerson@google.com BUG= https://github.com/dart-lang/sdk/issues/24279 Review URL: https://codereview.chromium.org/1380103005 .
863 lines
27 KiB
Dart
863 lines
27 KiB
Dart
// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
library test.analysis.notification.outline;
|
|
|
|
import 'dart:async';
|
|
|
|
import 'package:analysis_server/src/constants.dart';
|
|
import 'package:analysis_server/src/protocol.dart';
|
|
import 'package:test_reflective_loader/test_reflective_loader.dart';
|
|
import 'package:unittest/unittest.dart';
|
|
|
|
import '../analysis_abstract.dart';
|
|
import '../utils.dart';
|
|
|
|
main() {
|
|
initializeTestEnvironment();
|
|
defineReflectiveTests(_AnalysisNotificationOutlineTest);
|
|
}
|
|
|
|
@reflectiveTest
|
|
class _AnalysisNotificationOutlineTest extends AbstractAnalysisTest {
|
|
FileKind fileKind;
|
|
String libraryName;
|
|
Outline outline;
|
|
|
|
Future prepareOutline() {
|
|
addAnalysisSubscription(AnalysisService.OUTLINE, testFile);
|
|
return waitForTasksFinished();
|
|
}
|
|
|
|
void processNotification(Notification notification) {
|
|
if (notification.event == ANALYSIS_OUTLINE) {
|
|
var params = new AnalysisOutlineParams.fromNotification(notification);
|
|
if (params.file == testFile) {
|
|
fileKind = params.kind;
|
|
libraryName = params.libraryName;
|
|
outline = params.outline;
|
|
}
|
|
}
|
|
}
|
|
|
|
@override
|
|
void setUp() {
|
|
super.setUp();
|
|
createProject();
|
|
}
|
|
|
|
test_afterAnalysis() {
|
|
addTestFile('''
|
|
class AAA {
|
|
}
|
|
class BBB {
|
|
}
|
|
''');
|
|
return waitForTasksFinished().then((_) {
|
|
expect(outline, isNull);
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> outlines = unitOutline.children;
|
|
expect(outlines, hasLength(2));
|
|
});
|
|
});
|
|
}
|
|
|
|
test_class() {
|
|
addTestFile('''
|
|
class A<K, V> {
|
|
int fa, fb;
|
|
String fc;
|
|
A(int i, String s);
|
|
A.name(num p);
|
|
A._privateName(num p);
|
|
static String ma(int pa) => null;
|
|
_mb(int pb);
|
|
String get propA => null;
|
|
set propB(int v) {}
|
|
}
|
|
class B {
|
|
B(int p);
|
|
}");
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> topOutlines = unitOutline.children;
|
|
expect(topOutlines, hasLength(2));
|
|
// A
|
|
{
|
|
Outline outline_A = topOutlines[0];
|
|
Element element_A = outline_A.element;
|
|
expect(element_A.kind, ElementKind.CLASS);
|
|
expect(element_A.name, "A");
|
|
expect(element_A.typeParameters, "<K, V>");
|
|
{
|
|
Location location = element_A.location;
|
|
expect(location.offset, testCode.indexOf("A<K, V> {"));
|
|
expect(location.length, 1);
|
|
}
|
|
expect(element_A.parameters, null);
|
|
expect(element_A.returnType, null);
|
|
// A children
|
|
List<Outline> outlines_A = outline_A.children;
|
|
expect(outlines_A, hasLength(10));
|
|
{
|
|
Outline outline = outlines_A[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FIELD);
|
|
expect(element.name, "fa");
|
|
expect(element.parameters, isNull);
|
|
expect(element.returnType, "int");
|
|
}
|
|
{
|
|
Outline outline = outlines_A[1];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FIELD);
|
|
expect(element.name, "fb");
|
|
expect(element.parameters, isNull);
|
|
expect(element.returnType, "int");
|
|
}
|
|
{
|
|
Outline outline = outlines_A[2];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FIELD);
|
|
expect(element.name, "fc");
|
|
expect(element.parameters, isNull);
|
|
expect(element.returnType, "String");
|
|
}
|
|
{
|
|
Outline outline = outlines_A[3];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.CONSTRUCTOR);
|
|
expect(element.name, "A");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("A(int i, String s);"));
|
|
expect(location.length, "A".length);
|
|
}
|
|
expect(element.parameters, "(int i, String s)");
|
|
expect(element.returnType, isNull);
|
|
expect(element.isAbstract, isFalse);
|
|
expect(element.isStatic, isFalse);
|
|
}
|
|
{
|
|
Outline outline = outlines_A[4];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.CONSTRUCTOR);
|
|
expect(element.name, "A.name");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("name(num p);"));
|
|
expect(location.length, "name".length);
|
|
}
|
|
expect(element.parameters, "(num p)");
|
|
expect(element.returnType, isNull);
|
|
expect(element.isAbstract, isFalse);
|
|
expect(element.isStatic, isFalse);
|
|
}
|
|
{
|
|
Outline outline = outlines_A[5];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.CONSTRUCTOR);
|
|
expect(element.name, "A._privateName");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("_privateName(num p);"));
|
|
expect(location.length, "_privateName".length);
|
|
}
|
|
expect(element.parameters, "(num p)");
|
|
expect(element.returnType, isNull);
|
|
expect(element.isAbstract, isFalse);
|
|
expect(element.isStatic, isFalse);
|
|
}
|
|
{
|
|
Outline outline = outlines_A[6];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.METHOD);
|
|
expect(element.name, "ma");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("ma(int pa) => null;"));
|
|
expect(location.length, "ma".length);
|
|
}
|
|
expect(element.parameters, "(int pa)");
|
|
expect(element.returnType, "String");
|
|
expect(element.isAbstract, isFalse);
|
|
expect(element.isStatic, isTrue);
|
|
}
|
|
{
|
|
Outline outline = outlines_A[7];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.METHOD);
|
|
expect(element.name, "_mb");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("_mb(int pb);"));
|
|
expect(location.length, "_mb".length);
|
|
}
|
|
expect(element.parameters, "(int pb)");
|
|
expect(element.returnType, "");
|
|
expect(element.isAbstract, isTrue);
|
|
expect(element.isStatic, isFalse);
|
|
}
|
|
{
|
|
Outline outline = outlines_A[8];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.GETTER);
|
|
expect(element.name, "propA");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("propA => null;"));
|
|
expect(location.length, "propA".length);
|
|
}
|
|
expect(element.parameters, isNull);
|
|
expect(element.returnType, "String");
|
|
}
|
|
{
|
|
Outline outline = outlines_A[9];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.SETTER);
|
|
expect(element.name, "propB");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("propB(int v) {}"));
|
|
expect(location.length, "propB".length);
|
|
}
|
|
expect(element.parameters, "(int v)");
|
|
expect(element.returnType, "");
|
|
}
|
|
}
|
|
// B
|
|
{
|
|
Outline outline_B = topOutlines[1];
|
|
Element element_B = outline_B.element;
|
|
expect(element_B.kind, ElementKind.CLASS);
|
|
expect(element_B.name, "B");
|
|
expect(element_B.typeParameters, isNull);
|
|
{
|
|
Location location = element_B.location;
|
|
expect(location.offset, testCode.indexOf("B {"));
|
|
expect(location.length, 1);
|
|
}
|
|
expect(element_B.parameters, null);
|
|
expect(element_B.returnType, null);
|
|
// B children
|
|
List<Outline> outlines_B = outline_B.children;
|
|
expect(outlines_B, hasLength(1));
|
|
{
|
|
Outline outline = outlines_B[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.CONSTRUCTOR);
|
|
expect(element.name, "B");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("B(int p);"));
|
|
expect(location.length, "B".length);
|
|
}
|
|
expect(element.parameters, "(int p)");
|
|
expect(element.returnType, isNull);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
test_enum() {
|
|
addTestFile('''
|
|
enum MyEnum {
|
|
A, B, C
|
|
}
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> topOutlines = unitOutline.children;
|
|
expect(topOutlines, hasLength(1));
|
|
// MyEnum
|
|
{
|
|
Outline outline_MyEnum = topOutlines[0];
|
|
Element element_MyEnum = outline_MyEnum.element;
|
|
expect(element_MyEnum.kind, ElementKind.ENUM);
|
|
expect(element_MyEnum.name, "MyEnum");
|
|
{
|
|
Location location = element_MyEnum.location;
|
|
expect(location.offset, testCode.indexOf("MyEnum {"));
|
|
expect(location.length, 'MyEnum'.length);
|
|
}
|
|
expect(element_MyEnum.parameters, null);
|
|
expect(element_MyEnum.returnType, null);
|
|
// MyEnum children
|
|
List<Outline> outlines_MyEnum = outline_MyEnum.children;
|
|
expect(outlines_MyEnum, hasLength(3));
|
|
_isEnumConstant(outlines_MyEnum[0], 'A');
|
|
_isEnumConstant(outlines_MyEnum[1], 'B');
|
|
_isEnumConstant(outlines_MyEnum[2], 'C');
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Code like this caused NPE in the past.
|
|
*
|
|
* https://code.google.com/p/dart/issues/detail?id=21373
|
|
*/
|
|
test_invalidGetterInConstructor() {
|
|
addTestFile('''
|
|
class A {
|
|
A() {
|
|
get badGetter {
|
|
const int CONST = 0;
|
|
}
|
|
}
|
|
}
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
expect(outline, isNotNull);
|
|
});
|
|
}
|
|
|
|
test_libraryName_hasLibraryDirective() async {
|
|
addTestFile('''
|
|
library my.lib;
|
|
''');
|
|
await prepareOutline();
|
|
expect(fileKind, FileKind.LIBRARY);
|
|
expect(libraryName, 'my.lib');
|
|
}
|
|
|
|
test_libraryName_hasLibraryPartOfDirectives() async {
|
|
addTestFile('''
|
|
part of lib.in.part.of;
|
|
library my.lib;
|
|
''');
|
|
await prepareOutline();
|
|
expect(fileKind, FileKind.LIBRARY);
|
|
expect(libraryName, 'my.lib');
|
|
}
|
|
|
|
test_libraryName_hasPartOfDirective() async {
|
|
addTestFile('''
|
|
part of my.lib;
|
|
''');
|
|
await prepareOutline();
|
|
expect(fileKind, FileKind.PART);
|
|
expect(libraryName, 'my.lib');
|
|
}
|
|
|
|
test_libraryName_noDirectives() async {
|
|
addTestFile('''
|
|
class A {}
|
|
''');
|
|
await prepareOutline();
|
|
expect(fileKind, FileKind.LIBRARY);
|
|
expect(libraryName, isNull);
|
|
}
|
|
|
|
test_localFunctions() {
|
|
addTestFile('''
|
|
class A {
|
|
A() {
|
|
int local_A() {}
|
|
}
|
|
m() {
|
|
local_m() {}
|
|
}
|
|
}
|
|
f() {
|
|
local_f1(int i) {}
|
|
local_f2(String s) {
|
|
local_f21(int p) {}
|
|
}
|
|
}
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> topOutlines = unitOutline.children;
|
|
expect(topOutlines, hasLength(2));
|
|
// A
|
|
{
|
|
Outline outline_A = topOutlines[0];
|
|
Element element_A = outline_A.element;
|
|
expect(element_A.kind, ElementKind.CLASS);
|
|
expect(element_A.name, "A");
|
|
{
|
|
Location location = element_A.location;
|
|
expect(location.offset, testCode.indexOf("A {"));
|
|
expect(location.length, "A".length);
|
|
}
|
|
expect(element_A.parameters, null);
|
|
expect(element_A.returnType, null);
|
|
// A children
|
|
List<Outline> outlines_A = outline_A.children;
|
|
expect(outlines_A, hasLength(2));
|
|
{
|
|
Outline constructorOutline = outlines_A[0];
|
|
Element constructorElement = constructorOutline.element;
|
|
expect(constructorElement.kind, ElementKind.CONSTRUCTOR);
|
|
expect(constructorElement.name, "A");
|
|
{
|
|
Location location = constructorElement.location;
|
|
expect(location.offset, testCode.indexOf("A() {"));
|
|
expect(location.length, "A".length);
|
|
}
|
|
expect(constructorElement.parameters, "()");
|
|
expect(constructorElement.returnType, isNull);
|
|
// local function
|
|
List<Outline> outlines_constructor = constructorOutline.children;
|
|
expect(outlines_constructor, hasLength(1));
|
|
{
|
|
Outline outline = outlines_constructor[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FUNCTION);
|
|
expect(element.name, "local_A");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("local_A() {}"));
|
|
expect(location.length, "local_A".length);
|
|
}
|
|
expect(element.parameters, "()");
|
|
expect(element.returnType, "int");
|
|
}
|
|
}
|
|
{
|
|
Outline outline_m = outlines_A[1];
|
|
Element element_m = outline_m.element;
|
|
expect(element_m.kind, ElementKind.METHOD);
|
|
expect(element_m.name, "m");
|
|
{
|
|
Location location = element_m.location;
|
|
expect(location.offset, testCode.indexOf("m() {"));
|
|
expect(location.length, "m".length);
|
|
}
|
|
expect(element_m.parameters, "()");
|
|
expect(element_m.returnType, "");
|
|
// local function
|
|
List<Outline> methodChildren = outline_m.children;
|
|
expect(methodChildren, hasLength(1));
|
|
{
|
|
Outline outline = methodChildren[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FUNCTION);
|
|
expect(element.name, "local_m");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("local_m() {}"));
|
|
expect(location.length, "local_m".length);
|
|
}
|
|
expect(element.parameters, "()");
|
|
expect(element.returnType, "");
|
|
}
|
|
}
|
|
}
|
|
// f()
|
|
{
|
|
Outline outline_f = topOutlines[1];
|
|
Element element_f = outline_f.element;
|
|
expect(element_f.kind, ElementKind.FUNCTION);
|
|
expect(element_f.name, "f");
|
|
{
|
|
Location location = element_f.location;
|
|
expect(location.offset, testCode.indexOf("f() {"));
|
|
expect(location.length, "f".length);
|
|
}
|
|
expect(element_f.parameters, "()");
|
|
expect(element_f.returnType, "");
|
|
// f() children
|
|
List<Outline> outlines_f = outline_f.children;
|
|
expect(outlines_f, hasLength(2));
|
|
{
|
|
Outline outline_f1 = outlines_f[0];
|
|
Element element_f1 = outline_f1.element;
|
|
expect(element_f1.kind, ElementKind.FUNCTION);
|
|
expect(element_f1.name, "local_f1");
|
|
{
|
|
Location location = element_f1.location;
|
|
expect(location.offset, testCode.indexOf("local_f1(int i) {}"));
|
|
expect(location.length, "local_f1".length);
|
|
}
|
|
expect(element_f1.parameters, "(int i)");
|
|
expect(element_f1.returnType, "");
|
|
}
|
|
{
|
|
Outline outline_f2 = outlines_f[1];
|
|
Element element_f2 = outline_f2.element;
|
|
expect(element_f2.kind, ElementKind.FUNCTION);
|
|
expect(element_f2.name, "local_f2");
|
|
{
|
|
Location location = element_f2.location;
|
|
expect(location.offset, testCode.indexOf("local_f2(String s) {"));
|
|
expect(location.length, "local_f2".length);
|
|
}
|
|
expect(element_f2.parameters, "(String s)");
|
|
expect(element_f2.returnType, "");
|
|
// local_f2() local function
|
|
List<Outline> outlines_f2 = outline_f2.children;
|
|
expect(outlines_f2, hasLength(1));
|
|
{
|
|
Outline outline_f21 = outlines_f2[0];
|
|
Element element_f21 = outline_f21.element;
|
|
expect(element_f21.kind, ElementKind.FUNCTION);
|
|
expect(element_f21.name, "local_f21");
|
|
{
|
|
Location location = element_f21.location;
|
|
expect(location.offset, testCode.indexOf("local_f21(int p) {"));
|
|
expect(location.length, "local_f21".length);
|
|
}
|
|
expect(element_f21.parameters, "(int p)");
|
|
expect(element_f21.returnType, "");
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
test_sourceRange_inClass() {
|
|
addTestFile('''
|
|
class A { // leftA
|
|
int methodA() {} // endA
|
|
int methodB() {} // endB
|
|
}
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> outlines = unitOutline.children[0].children;
|
|
expect(outlines, hasLength(2));
|
|
// methodA
|
|
{
|
|
Outline outline = outlines[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.METHOD);
|
|
expect(element.name, "methodA");
|
|
{
|
|
int offset = testCode.indexOf(" // leftA");
|
|
int end = testCode.indexOf(" // endA");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
// methodB
|
|
{
|
|
Outline outline = outlines[1];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.METHOD);
|
|
expect(element.name, "methodB");
|
|
{
|
|
int offset = testCode.indexOf(" // endA");
|
|
int end = testCode.indexOf(" // endB");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
test_sourceRange_inClass_inVariableList() {
|
|
addTestFile('''
|
|
class A { // leftA
|
|
int fieldA, fieldB, fieldC; // marker
|
|
int fieldD; // marker2
|
|
}
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> outlines = unitOutline.children[0].children;
|
|
expect(outlines, hasLength(4));
|
|
// fieldA
|
|
{
|
|
Outline outline = outlines[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FIELD);
|
|
expect(element.name, "fieldA");
|
|
{
|
|
int offset = testCode.indexOf(" // leftA");
|
|
int end = testCode.indexOf(", fieldB");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
// fieldB
|
|
{
|
|
Outline outline = outlines[1];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FIELD);
|
|
expect(element.name, "fieldB");
|
|
{
|
|
int offset = testCode.indexOf(", fieldB");
|
|
int end = testCode.indexOf(", fieldC");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
// fieldC
|
|
{
|
|
Outline outline = outlines[2];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FIELD);
|
|
expect(element.name, "fieldC");
|
|
{
|
|
int offset = testCode.indexOf(", fieldC");
|
|
int end = testCode.indexOf(" // marker");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
// fieldD
|
|
{
|
|
Outline outline = outlines[3];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FIELD);
|
|
expect(element.name, "fieldD");
|
|
{
|
|
int offset = testCode.indexOf(" // marker");
|
|
int end = testCode.indexOf(" // marker2");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
test_sourceRange_inUnit() {
|
|
addTestFile('''
|
|
library lib;
|
|
/// My first class.
|
|
class A {
|
|
} // endA
|
|
class B {
|
|
} // endB
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> topOutlines = unitOutline.children;
|
|
expect(topOutlines, hasLength(2));
|
|
// A
|
|
{
|
|
Outline outline = topOutlines[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.CLASS);
|
|
expect(element.name, "A");
|
|
{
|
|
int offset = testCode.indexOf("/// My first class.");
|
|
int end = testCode.indexOf(" // endA");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
// B
|
|
{
|
|
Outline outline = topOutlines[1];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.CLASS);
|
|
expect(element.name, "B");
|
|
{
|
|
int offset = testCode.indexOf(" // endA");
|
|
int end = testCode.indexOf(" // endB");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
test_sourceRange_inUnit_inVariableList() {
|
|
addTestFile('''
|
|
int fieldA, fieldB, fieldC; // marker
|
|
int fieldD; // marker2
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> outlines = unitOutline.children;
|
|
expect(outlines, hasLength(4));
|
|
// fieldA
|
|
{
|
|
Outline outline = outlines[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.TOP_LEVEL_VARIABLE);
|
|
expect(element.name, "fieldA");
|
|
{
|
|
int offset = 0;
|
|
int end = testCode.indexOf(", fieldB");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
// fieldB
|
|
{
|
|
Outline outline = outlines[1];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.TOP_LEVEL_VARIABLE);
|
|
expect(element.name, "fieldB");
|
|
{
|
|
int offset = testCode.indexOf(", fieldB");
|
|
int end = testCode.indexOf(", fieldC");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
// fieldC
|
|
{
|
|
Outline outline = outlines[2];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.TOP_LEVEL_VARIABLE);
|
|
expect(element.name, "fieldC");
|
|
{
|
|
int offset = testCode.indexOf(", fieldC");
|
|
int end = testCode.indexOf(" // marker");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
// fieldD
|
|
{
|
|
Outline outline = outlines[3];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.TOP_LEVEL_VARIABLE);
|
|
expect(element.name, "fieldD");
|
|
{
|
|
int offset = testCode.indexOf(" // marker");
|
|
int end = testCode.indexOf(" // marker2");
|
|
expect(outline.offset, offset);
|
|
expect(outline.length, end - offset);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
test_topLevel() {
|
|
addTestFile('''
|
|
typedef String FTA<K, V>(int i, String s);
|
|
typedef FTB(int p);
|
|
class A<T> {}
|
|
class B {}
|
|
class CTA<T> = A<T> with B;
|
|
class CTB = A with B;
|
|
String fA(int i, String s) => null;
|
|
fB(int p) => null;
|
|
String get propA => null;
|
|
set propB(int v) {}
|
|
''');
|
|
return prepareOutline().then((_) {
|
|
Outline unitOutline = outline;
|
|
List<Outline> topOutlines = unitOutline.children;
|
|
expect(topOutlines, hasLength(10));
|
|
// FTA
|
|
{
|
|
Outline outline = topOutlines[0];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FUNCTION_TYPE_ALIAS);
|
|
expect(element.name, "FTA");
|
|
expect(element.typeParameters, "<K, V>");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("FTA<K, V>("));
|
|
expect(location.length, "FTA".length);
|
|
}
|
|
expect(element.parameters, "(int i, String s)");
|
|
expect(element.returnType, "String");
|
|
}
|
|
// FTB
|
|
{
|
|
Outline outline = topOutlines[1];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FUNCTION_TYPE_ALIAS);
|
|
expect(element.name, "FTB");
|
|
expect(element.typeParameters, isNull);
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("FTB("));
|
|
expect(location.length, "FTB".length);
|
|
}
|
|
expect(element.parameters, "(int p)");
|
|
expect(element.returnType, "");
|
|
}
|
|
// CTA
|
|
{
|
|
Outline outline = topOutlines[4];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.CLASS_TYPE_ALIAS);
|
|
expect(element.name, "CTA");
|
|
expect(element.typeParameters, '<T>');
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("CTA<T> ="));
|
|
expect(location.length, "CTA".length);
|
|
}
|
|
expect(element.parameters, isNull);
|
|
expect(element.returnType, isNull);
|
|
}
|
|
// CTB
|
|
{
|
|
Outline outline = topOutlines[5];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.CLASS_TYPE_ALIAS);
|
|
expect(element.name, 'CTB');
|
|
expect(element.typeParameters, isNull);
|
|
expect(element.returnType, isNull);
|
|
}
|
|
// fA
|
|
{
|
|
Outline outline = topOutlines[6];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FUNCTION);
|
|
expect(element.name, "fA");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("fA("));
|
|
expect(location.length, "fA".length);
|
|
}
|
|
expect(element.parameters, "(int i, String s)");
|
|
expect(element.returnType, "String");
|
|
}
|
|
// fB
|
|
{
|
|
Outline outline = topOutlines[7];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.FUNCTION);
|
|
expect(element.name, "fB");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("fB("));
|
|
expect(location.length, "fB".length);
|
|
}
|
|
expect(element.parameters, "(int p)");
|
|
expect(element.returnType, "");
|
|
}
|
|
// propA
|
|
{
|
|
Outline outline = topOutlines[8];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.GETTER);
|
|
expect(element.name, "propA");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("propA => null;"));
|
|
expect(location.length, "propA".length);
|
|
}
|
|
expect(element.parameters, "");
|
|
expect(element.returnType, "String");
|
|
}
|
|
// propB
|
|
{
|
|
Outline outline = topOutlines[9];
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.SETTER);
|
|
expect(element.name, "propB");
|
|
{
|
|
Location location = element.location;
|
|
expect(location.offset, testCode.indexOf("propB(int v) {}"));
|
|
expect(location.length, "propB".length);
|
|
}
|
|
expect(element.parameters, "(int v)");
|
|
expect(element.returnType, "");
|
|
}
|
|
});
|
|
}
|
|
|
|
void _isEnumConstant(Outline outline, String name) {
|
|
Element element = outline.element;
|
|
expect(element.kind, ElementKind.ENUM_CONSTANT);
|
|
expect(element.name, name);
|
|
expect(element.parameters, isNull);
|
|
expect(element.returnType, isNull);
|
|
}
|
|
}
|