Move Engine to Server element / error converters into protocol_server.dart

pkg/analysis_server/test/protocol_server_test.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/constants.dart';
 import 'package:analysis_server/src/protocol_server.dart';
-import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/ast.dart' as engine;
 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:analyzer/src/generated/error.dart' as engine;
+import 'package:analyzer/src/generated/source.dart' as engine;
+import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
-import '../abstract_context.dart';
-import '../reflective_tests.dart';
+import 'abstract_context.dart';
+import 'mocks.dart';
+import 'reflective_tests.dart';
 
 
 
 main() {
   groupSep = ' | ';
+  runReflectiveTests(AnalysisErrorTest);
   runReflectiveTests(ElementTest);
   runReflectiveTests(ElementKindTest);
 }
 
 
+class AnalysisErrorMock extends TypedMock implements engine.AnalysisError {
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+
+@ReflectiveTestCase()
+class AnalysisErrorTest {
+  engine.Source source = new MockSource();
+  engine.LineInfo lineInfo;
+  engine.AnalysisError engineError = new AnalysisErrorMock();
+
+  void setUp() {
+    // prepare Source
+    when(source.fullName).thenReturn('foo.dart');
+    // prepare LineInfo
+    lineInfo = new engine.LineInfo([0, 5, 9, 20]);
+    // prepare AnalysisError
+    when(engineError.source).thenReturn(source);
+    when(
+        engineError.errorCode).thenReturn(engine.CompileTimeErrorCode.AMBIGUOUS_EXPORT);
+    when(engineError.message).thenReturn('my message');
+    when(engineError.offset).thenReturn(10);
+    when(engineError.length).thenReturn(20);
+  }
+
+  void tearDown() {
+    source = null;
+    engineError = null;
+  }
+
+  void test_fromEngine_hasCorrection() {
+    when(engineError.correction).thenReturn('my correction');
+    AnalysisError error = newAnalysisError_fromEngine(lineInfo, engineError);
+    expect(error.toJson(), {
+      SEVERITY: 'ERROR',
+      TYPE: 'COMPILE_TIME_ERROR',
+      LOCATION: {
+        FILE: 'foo.dart',
+        OFFSET: 10,
+        LENGTH: 20,
+        START_LINE: 3,
+        START_COLUMN: 2
+      },
+      MESSAGE: 'my message',
+      CORRECTION: 'my correction'
+    });
+  }
+
+  void test_fromEngine_noCorrection() {
+    when(engineError.correction).thenReturn(null);
+    AnalysisError error = newAnalysisError_fromEngine(lineInfo, engineError);
+    expect(error.toJson(), {
+      SEVERITY: 'ERROR',
+      TYPE: 'COMPILE_TIME_ERROR',
+      LOCATION: {
+        FILE: 'foo.dart',
+        OFFSET: 10,
+        LENGTH: 20,
+        START_LINE: 3,
+        START_COLUMN: 2
+      },
+      MESSAGE: 'my message'
+    });
+  }
+
+  void test_fromEngine_noLineInfo() {
+    when(engineError.correction).thenReturn(null);
+    AnalysisError error = newAnalysisError_fromEngine(null, engineError);
+    expect(error.toJson(), {
+      SEVERITY: 'ERROR',
+      TYPE: 'COMPILE_TIME_ERROR',
+      LOCATION: {
+        FILE: 'foo.dart',
+        OFFSET: 10,
+        LENGTH: 20,
+        START_LINE: -1,
+        START_COLUMN: -1
+      },
+      MESSAGE: 'my message'
+    });
+  }
+}
+
+
 class ElementKindTest {
   void test_fromEngine() {
     expect(
         newElementKind_fromEngine(engine.ElementKind.CLASS),
         ElementKind.CLASS);
     expect(
         newElementKind_fromEngine(engine.ElementKind.COMPILATION_UNIT),
         ElementKind.COMPILATION_UNIT);
     expect(
         newElementKind_fromEngine(engine.ElementKind.CONSTRUCTOR),
@@ skipping 85 matching lines @@
     expect(ElementKind.CLASS.toString(), 'ElementKind.CLASS');
     expect(
         ElementKind.COMPILATION_UNIT.toString(),
         'ElementKind.COMPILATION_UNIT');
   }
 }
 
 
 @ReflectiveTestCase()
 class ElementTest extends AbstractContextTest {
-  engine.Element findElementInUnit(CompilationUnit unit, String name,
+  engine.Element findElementInUnit(engine.CompilationUnit unit, String name,
       [engine.ElementKind kind]) {
     return findChildElement(unit.element, name, kind);
   }
 
   void test_fromElement_CLASS() {
-    Source source = addSource('/test.dart', '''
+    engine.Source source = addSource('/test.dart', '''
 @deprecated
 abstract class _MyClass {}''');
-    CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = resolveLibraryUnit(source);
     engine.ClassElement engineElement = findElementInUnit(unit, '_MyClass');
     // create notification Element
     Element element = newElement_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', '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   const A.myConstructor(int a, [String b]);
 }''');
-    CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = resolveLibraryUnit(source);
     engine.ConstructorElement engineElement =
         findElementInUnit(unit, 'myConstructor');
     // create notification Element
     Element element = newElement_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', '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   static const myField = 42;
 }''');
-    CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = resolveLibraryUnit(source);
     engine.FieldElement engineElement = findElementInUnit(unit, 'myField');
     // create notification Element
     Element element = newElement_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', '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   String myGetter => 42;
 }''');
-    CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = resolveLibraryUnit(source);
     engine.PropertyAccessorElement engineElement =
         findElementInUnit(unit, 'myGetter', engine.ElementKind.GETTER);
     // create notification Element
     Element element = newElement_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_LABEL() {
-    Source source = addSource('/test.dart', '''
+    engine.Source source = addSource('/test.dart', '''
 main() {
 myLabel:
   while (true) {
     break myLabel;
   }
 }''');
-    CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = resolveLibraryUnit(source);
     engine.LabelElement engineElement = findElementInUnit(unit, 'myLabel');
     // create notification Element
     Element element = newElement_fromEngine(engineElement);
     expect(element.kind, ElementKind.LABEL);
     expect(element.name, 'myLabel');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
       expect(location.offset, 9);
       expect(location.length, 'myLabel'.length);
       expect(location.startLine, 2);
       expect(location.startColumn, 1);
     }
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 
   void test_fromElement_METHOD() {
-    Source source = addSource('/test.dart', '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   static List<String> myMethod(int a, {String b}) {
     return null;
   }
 }''');
-    CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = resolveLibraryUnit(source);
     engine.MethodElement engineElement = findElementInUnit(unit, 'myMethod');
     // create notification Element
     Element element = newElement_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_fromElement_SETTER() {
-    Source source = addSource('/test.dart', '''
+    engine.Source source = addSource('/test.dart', '''
 class A {
   set mySetter(String x) {}
 }''');
-    CompilationUnit unit = resolveLibraryUnit(source);
+    engine.CompilationUnit unit = resolveLibraryUnit(source);
     engine.FieldElement engineFieldElement =
         findElementInUnit(unit, 'mySetter', engine.ElementKind.FIELD);
     engine.PropertyAccessorElement engineElement = engineFieldElement.setter;
     // create notification Element
     Element element = newElement_fromEngine(engineElement);
     expect(element.kind, ElementKind.SETTER);
     expect(element.name, 'mySetter');
     {
       Location location = element.location;
       expect(location.file, '/test.dart');
@@ skipping 12 matching lines @@
     // create notification Element
     Element element = newElement_fromEngine(engineElement);
     expect(element.kind, ElementKind.UNKNOWN);
     expect(element.name, 'dynamic');
     expect(element.location, isNull);
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
     expect(element.flags, 0);
   }
 }