paulberry@google.com
c5ff06636b
Generated code is now used to process input JSON, and to create requests and process responses in unit tests. In addition, the handwritten classes for ElementKind and SourceEdit have been replaced with the gennerated versions. Also some dead code has been removed. R=scheglov@google.com Review URL: https://codereview.chromium.org//492563002 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@39404 260f80e4-7a28-3924-810f-c04153c831b5
320 lines
10 KiB
Dart
320 lines
10 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.computer.element;
|
|
|
|
import 'package:analysis_server/src/computer/element.dart';
|
|
import 'package:analysis_server/src/constants.dart';
|
|
import 'package:analysis_server/src/protocol2.dart' show ElementKind;
|
|
import 'package:analysis_testing/abstract_context.dart';
|
|
import 'package:analysis_testing/reflective_tests.dart';
|
|
import 'package:analyzer/src/generated/ast.dart';
|
|
import 'package:analyzer/src/generated/element.dart' as engine;
|
|
import 'package:analyzer/src/generated/source.dart';
|
|
import 'package:analyzer/src/generated/utilities_dart.dart' as engine;
|
|
import 'package:unittest/unittest.dart';
|
|
|
|
|
|
|
|
main() {
|
|
groupSep = ' | ';
|
|
runReflectiveTests(ElementTest);
|
|
runReflectiveTests(ElementKindTest);
|
|
}
|
|
|
|
|
|
class ElementKindTest {
|
|
void test_toString() {
|
|
expect(ElementKind.CLASS.toString(), 'ElementKind.CLASS');
|
|
expect(ElementKind.COMPILATION_UNIT.toString(),
|
|
'ElementKind.COMPILATION_UNIT');
|
|
}
|
|
|
|
void test_string_constructor() {
|
|
expect(new ElementKind(ElementKind.CLASS.name), ElementKind.CLASS);
|
|
expect(
|
|
new ElementKind(ElementKind.CLASS_TYPE_ALIAS.name),
|
|
ElementKind.CLASS_TYPE_ALIAS);
|
|
expect(
|
|
new ElementKind(ElementKind.COMPILATION_UNIT.name),
|
|
ElementKind.COMPILATION_UNIT);
|
|
expect(
|
|
new ElementKind(ElementKind.CONSTRUCTOR.name),
|
|
ElementKind.CONSTRUCTOR);
|
|
expect(new ElementKind(ElementKind.FIELD.name), ElementKind.FIELD);
|
|
expect(
|
|
new ElementKind(ElementKind.FUNCTION.name),
|
|
ElementKind.FUNCTION);
|
|
expect(
|
|
new ElementKind(ElementKind.FUNCTION_TYPE_ALIAS.name),
|
|
ElementKind.FUNCTION_TYPE_ALIAS);
|
|
expect(new ElementKind(ElementKind.GETTER.name), ElementKind.GETTER);
|
|
expect(new ElementKind(ElementKind.LIBRARY.name), ElementKind.LIBRARY);
|
|
expect(
|
|
new ElementKind(ElementKind.LOCAL_VARIABLE.name),
|
|
ElementKind.LOCAL_VARIABLE);
|
|
expect(new ElementKind(ElementKind.METHOD.name), ElementKind.METHOD);
|
|
expect(
|
|
new ElementKind(ElementKind.PARAMETER.name),
|
|
ElementKind.PARAMETER);
|
|
expect(new ElementKind(ElementKind.SETTER.name), ElementKind.SETTER);
|
|
expect(
|
|
new ElementKind(ElementKind.TOP_LEVEL_VARIABLE.name),
|
|
ElementKind.TOP_LEVEL_VARIABLE);
|
|
expect(
|
|
new ElementKind(ElementKind.TYPE_PARAMETER.name),
|
|
ElementKind.TYPE_PARAMETER);
|
|
expect(
|
|
new ElementKind(ElementKind.UNIT_TEST_TEST.name),
|
|
ElementKind.UNIT_TEST_TEST);
|
|
expect(
|
|
new ElementKind(ElementKind.UNIT_TEST_GROUP.name),
|
|
ElementKind.UNIT_TEST_GROUP);
|
|
expect(new ElementKind(ElementKind.UNKNOWN.name), ElementKind.UNKNOWN);
|
|
expect(() {
|
|
new ElementKind('no-such-kind');
|
|
}, throws);
|
|
}
|
|
|
|
void test_valueOfEngine() {
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.CLASS),
|
|
ElementKind.CLASS);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.COMPILATION_UNIT),
|
|
ElementKind.COMPILATION_UNIT);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.CONSTRUCTOR),
|
|
ElementKind.CONSTRUCTOR);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.FIELD),
|
|
ElementKind.FIELD);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.FUNCTION),
|
|
ElementKind.FUNCTION);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.FUNCTION_TYPE_ALIAS),
|
|
ElementKind.FUNCTION_TYPE_ALIAS);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.GETTER),
|
|
ElementKind.GETTER);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.LIBRARY),
|
|
ElementKind.LIBRARY);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.LOCAL_VARIABLE),
|
|
ElementKind.LOCAL_VARIABLE);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.METHOD),
|
|
ElementKind.METHOD);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.PARAMETER),
|
|
ElementKind.PARAMETER);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.SETTER),
|
|
ElementKind.SETTER);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.TOP_LEVEL_VARIABLE),
|
|
ElementKind.TOP_LEVEL_VARIABLE);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.TYPE_PARAMETER),
|
|
ElementKind.TYPE_PARAMETER);
|
|
expect(
|
|
elementKindFromEngine(engine.ElementKind.ANGULAR_COMPONENT),
|
|
ElementKind.UNKNOWN);
|
|
}
|
|
}
|
|
|
|
|
|
@ReflectiveTestCase()
|
|
class ElementTest extends AbstractContextTest {
|
|
engine.Element findElementInUnit(CompilationUnit unit, String name,
|
|
[engine.ElementKind kind]) {
|
|
return findChildElement(unit.element, name, kind);
|
|
}
|
|
|
|
void test_fromElement_CLASS() {
|
|
Source source = addSource('/test.dart', '''
|
|
@deprecated
|
|
abstract class _MyClass {}''');
|
|
CompilationUnit unit = resolveLibraryUnit(source);
|
|
engine.ClassElement engineElement = findElementInUnit(unit, '_MyClass');
|
|
// create notification Element
|
|
Element element = new Element.fromEngine(engineElement);
|
|
expect(element.kind, ElementKind.CLASS);
|
|
expect(element.name, '_MyClass');
|
|
{
|
|
Location location = element.location;
|
|
expect(location.file, '/test.dart');
|
|
expect(location.offset, 27);
|
|
expect(location.length, '_MyClass'.length);
|
|
expect(location.startLine, 2);
|
|
expect(location.startColumn, 16);
|
|
}
|
|
expect(
|
|
element.flags,
|
|
Element.FLAG_ABSTRACT | Element.FLAG_DEPRECATED | Element.FLAG_PRIVATE);
|
|
}
|
|
|
|
void test_fromElement_CONSTRUCTOR() {
|
|
Source source = addSource('/test.dart', '''
|
|
class A {
|
|
const A.myConstructor(int a, [String b]);
|
|
}''');
|
|
CompilationUnit unit = resolveLibraryUnit(source);
|
|
engine.ConstructorElement engineElement =
|
|
findElementInUnit(unit, 'myConstructor');
|
|
// create notification Element
|
|
Element element = new Element.fromEngine(engineElement);
|
|
expect(element.kind, ElementKind.CONSTRUCTOR);
|
|
expect(element.name, 'myConstructor');
|
|
{
|
|
Location location = element.location;
|
|
expect(location.file, '/test.dart');
|
|
expect(location.offset, 20);
|
|
expect(location.length, 'myConstructor'.length);
|
|
expect(location.startLine, 2);
|
|
expect(location.startColumn, 11);
|
|
}
|
|
expect(element.parameters, '(int a, [String b])');
|
|
expect(element.returnType, 'A');
|
|
expect(element.flags, Element.FLAG_CONST);
|
|
}
|
|
|
|
void test_fromElement_FIELD() {
|
|
Source source = addSource('/test.dart', '''
|
|
class A {
|
|
static const myField = 42;
|
|
}''');
|
|
CompilationUnit unit = resolveLibraryUnit(source);
|
|
engine.FieldElement engineElement = findElementInUnit(unit, 'myField');
|
|
// create notification Element
|
|
Element element = new Element.fromEngine(engineElement);
|
|
expect(element.kind, ElementKind.FIELD);
|
|
expect(element.name, 'myField');
|
|
{
|
|
Location location = element.location;
|
|
expect(location.file, '/test.dart');
|
|
expect(location.offset, 25);
|
|
expect(location.length, 'myField'.length);
|
|
expect(location.startLine, 2);
|
|
expect(location.startColumn, 16);
|
|
}
|
|
expect(element.parameters, isNull);
|
|
expect(element.returnType, isNull);
|
|
expect(element.flags, Element.FLAG_CONST | Element.FLAG_STATIC);
|
|
}
|
|
|
|
void test_fromElement_GETTER() {
|
|
Source source = addSource('/test.dart', '''
|
|
class A {
|
|
String myGetter => 42;
|
|
}''');
|
|
CompilationUnit unit = resolveLibraryUnit(source);
|
|
engine.PropertyAccessorElement engineElement =
|
|
findElementInUnit(unit, 'myGetter', engine.ElementKind.GETTER);
|
|
// create notification Element
|
|
Element element = new Element.fromEngine(engineElement);
|
|
expect(element.kind, ElementKind.GETTER);
|
|
expect(element.name, 'myGetter');
|
|
{
|
|
Location location = element.location;
|
|
expect(location.file, '/test.dart');
|
|
expect(location.offset, 19);
|
|
expect(location.length, 'myGetter'.length);
|
|
expect(location.startLine, 2);
|
|
expect(location.startColumn, 10);
|
|
}
|
|
expect(element.parameters, '()');
|
|
expect(element.returnType, 'String');
|
|
expect(element.flags, 0);
|
|
}
|
|
|
|
void test_fromElement_METHOD() {
|
|
Source source = addSource('/test.dart', '''
|
|
class A {
|
|
static List<String> myMethod(int a, {String b}) {
|
|
return null;
|
|
}
|
|
}''');
|
|
CompilationUnit unit = resolveLibraryUnit(source);
|
|
engine.MethodElement engineElement = findElementInUnit(unit, 'myMethod');
|
|
// create notification Element
|
|
Element element = new Element.fromEngine(engineElement);
|
|
expect(element.kind, ElementKind.METHOD);
|
|
expect(element.name, 'myMethod');
|
|
{
|
|
Location location = element.location;
|
|
expect(location.file, '/test.dart');
|
|
expect(location.offset, 32);
|
|
expect(location.length, 'myGetter'.length);
|
|
expect(location.startLine, 2);
|
|
expect(location.startColumn, 23);
|
|
}
|
|
expect(element.parameters, '(int a, {String b})');
|
|
expect(element.returnType, 'List<String>');
|
|
expect(element.flags, Element.FLAG_STATIC);
|
|
}
|
|
|
|
void test_fromJson() {
|
|
var flags =
|
|
Element.FLAG_DEPRECATED |
|
|
Element.FLAG_PRIVATE |
|
|
Element.FLAG_STATIC;
|
|
var json = {
|
|
KIND: 'METHOD',
|
|
NAME: 'my name',
|
|
LOCATION: {
|
|
FILE: '/project/file.dart',
|
|
OFFSET: 1,
|
|
LENGTH: 2,
|
|
START_LINE: 3,
|
|
START_COLUMN: 4,
|
|
},
|
|
FLAGS: flags,
|
|
PARAMETERS: '(int a, String b)',
|
|
RETURN_TYPE: 'List<String>'
|
|
};
|
|
Element element = new Element.fromJson(json);
|
|
expect(element.kind, ElementKind.METHOD);
|
|
expect(element.name, 'my name');
|
|
{
|
|
Location location = element.location;
|
|
expect(location.file, '/project/file.dart');
|
|
expect(location.offset, 1);
|
|
expect(location.length, 2);
|
|
expect(location.startLine, 3);
|
|
expect(location.startColumn, 4);
|
|
}
|
|
expect(element.flags, flags);
|
|
expect(element.isAbstract, isFalse);
|
|
expect(element.isConst, isFalse);
|
|
expect(element.isDeprecated, isTrue);
|
|
expect(element.isFinal, isFalse);
|
|
expect(element.isPrivate, isTrue);
|
|
expect(element.isStatic, isTrue);
|
|
}
|
|
|
|
void test_toJson() {
|
|
var json = {
|
|
KIND: 'METHOD',
|
|
NAME: 'my name',
|
|
LOCATION: {
|
|
FILE: '/project/file.dart',
|
|
OFFSET: 1,
|
|
LENGTH: 2,
|
|
START_LINE: 3,
|
|
START_COLUMN: 4,
|
|
},
|
|
FLAGS: Element.FLAG_DEPRECATED |
|
|
Element.FLAG_PRIVATE |
|
|
Element.FLAG_STATIC,
|
|
PARAMETERS: '(int a, String b)',
|
|
RETURN_TYPE: 'List<String>'
|
|
};
|
|
Element element = new Element.fromJson(json);
|
|
expect(element.toJson(), equals(json));
|
|
}
|
|
}
|