Version 0.8.10.4

dart/editor/tools/plugins/com.google.dart.engine_test/src/com/google/dart/engine/internal/scope/ScopeBuilderTest.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
@@ skipping 39 matching lines @@
 import static com.google.dart.engine.element.ElementFactory.classElement;
 import static com.google.dart.engine.element.ElementFactory.constructorElement;
 import static com.google.dart.engine.element.ElementFactory.functionElement;
 import static com.google.dart.engine.element.ElementFactory.library;
 import static com.google.dart.engine.element.ElementFactory.methodElement;
 
 public class ScopeBuilderTest extends EngineTestCase {
   public void test_scopeFor_ClassDeclaration() throws AnalysisException {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope = ScopeBuilder.scopeFor(createResolvedClassDeclaration(), listener);
-    assertInstanceOf(ClassScope.class, scope);
+    assertInstanceOf(LibraryScope.class, scope);
   }
 
   public void test_scopeFor_ClassTypeAlias() throws AnalysisException {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope = ScopeBuilder.scopeFor(createResolvedClassTypeAlias(), listener);
-    assertInstanceOf(ClassScope.class, scope);
+    assertInstanceOf(LibraryScope.class, scope);
   }
 
   public void test_scopeFor_CompilationUnit() throws AnalysisException {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope = ScopeBuilder.scopeFor(createResolvedCompilationUnit(), listener);
     assertInstanceOf(LibraryScope.class, scope);
   }
 
   public void test_scopeFor_ConstructorDeclaration() throws AnalysisException {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope = ScopeBuilder.scopeFor(createResolvedConstructorDeclaration(), listener);
+    assertInstanceOf(ClassScope.class, scope);
+  }
+
+  public void test_scopeFor_ConstructorDeclaration_parameters() throws AnalysisException {
+    GatheringErrorListener listener = new GatheringErrorListener();
+    Scope scope = ScopeBuilder.scopeFor(
+        createResolvedConstructorDeclaration().getParameters(),
+        listener);
     assertInstanceOf(FunctionScope.class, scope);
   }
 
   public void test_scopeFor_FunctionDeclaration() throws AnalysisException {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope = ScopeBuilder.scopeFor(createResolvedFunctionDeclaration(), listener);
+    assertInstanceOf(LibraryScope.class, scope);
+  }
+
+  public void test_scopeFor_FunctionDeclaration_parameters() throws AnalysisException {
+    GatheringErrorListener listener = new GatheringErrorListener();
+    Scope scope = ScopeBuilder.scopeFor(
+        createResolvedFunctionDeclaration().getFunctionExpression().getParameters(),
+        listener);
     assertInstanceOf(FunctionScope.class, scope);
   }
 
   public void test_scopeFor_FunctionTypeAlias() throws AnalysisException {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope = ScopeBuilder.scopeFor(createResolvedFunctionTypeAlias(), listener);
+    assertInstanceOf(LibraryScope.class, scope);
+  }
+
+  public void test_scopeFor_FunctionTypeAlias_parameters() throws AnalysisException {
+    GatheringErrorListener listener = new GatheringErrorListener();
+    Scope scope = ScopeBuilder.scopeFor(createResolvedFunctionTypeAlias().getParameters(), listener);
     assertInstanceOf(FunctionTypeScope.class, scope);
   }
 
   public void test_scopeFor_MethodDeclaration() throws AnalysisException {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scope scope = ScopeBuilder.scopeFor(createResolvedMethodDeclaration(), listener);
+    assertInstanceOf(ClassScope.class, scope);
+  }
+
+  public void test_scopeFor_MethodDeclaration_body() throws AnalysisException {
+    GatheringErrorListener listener = new GatheringErrorListener();
+    Scope scope = ScopeBuilder.scopeFor(createResolvedMethodDeclaration().getBody(), listener);
     assertInstanceOf(FunctionScope.class, scope);
   }
 
   public void test_scopeFor_notInCompilationUnit() {
     GatheringErrorListener listener = new GatheringErrorListener();
     try {
       ScopeBuilder.scopeFor(identifier("x"), listener);
       fail("Expected AnalysisException");
     } catch (AnalysisException exception) {
       // Expected
@@ skipping 116 matching lines @@
         null,
         identifier(methodName),
         formalParameterList());
     classNode.getMembers().add(methodNode);
     MethodElement methodElement = methodElement(methodName, null);
     methodNode.getName().setStaticElement(methodElement);
     ((ClassElementImpl) classNode.getElement()).setMethods(new MethodElement[] {methodElement});
     return methodNode;
   }
 }