dart/editor/tools/plugins/com.google.dart.engine_test/src/com/google/dart/engine/integration/LibraryAnalysisTest.java - external/dart - Git at Google

 /*
  * 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
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.dart.engine.integration;

 import com.google.dart.engine.ast.CompilationUnit;
 import com.google.dart.engine.context.AnalysisContext;
 import com.google.dart.engine.context.AnalysisException;
 import com.google.dart.engine.element.CompilationUnitElement;
 import com.google.dart.engine.element.LibraryElement;
 import com.google.dart.engine.error.AnalysisError;
 import com.google.dart.engine.error.ErrorCode;
 import com.google.dart.engine.error.TodoCode;
 import com.google.dart.engine.internal.context.PerformanceStatistics;
 import com.google.dart.engine.internal.resolver.ResolutionVerifier;
 import com.google.dart.engine.internal.resolver.StaticTypeVerifier;
 import com.google.dart.engine.source.Source;
 import com.google.dart.engine.utilities.io.PrintStringWriter;

 import junit.framework.Assert;
 import junit.framework.TestCase;

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;

 /**
  * The abstract class {@code LibraryAnalysisTest} defines utility methods useful for integration
  * tests that analyze one or more libraries as a single test.
  */
 public abstract class LibraryAnalysisTest extends TestCase {
   /**
    * A set containing all of the libraries that have been visited as part of verifying the results
    * of analysis.
    */
   private HashSet<LibraryElement> visitedLibraries = new HashSet<LibraryElement>();

   /**
    * A flag indicating whether libraries that are part of the SDK should be validated.
    */
   private boolean validateSdk = false;

   /**
    * A list to which all of the errors in the libraries will be added.
    */
   private ArrayList<AnalysisError> errorList = new ArrayList<AnalysisError>();

   /**
    * The object used to verify that everything that ought to have a static type associated with it
    * has a static type.
    */
   private StaticTypeVerifier staticTypeVerifier = new StaticTypeVerifier();

   /**
    * The object used to verify that everything that ought to have been resolved was resolved.
    */
   private ResolutionVerifier resolutionVerifier = new ResolutionVerifier();

   /**
    * The object used to verify that the element structures of the libraries were correctly formed.
    */
   private ElementStructureVerifier elementVerifier = new ElementStructureVerifier();

   /**
    * The object used to verify that the containing libraries of the sources were correctly computed.
    */
   private ContainingLibrariesVerifier librariesVerifier = new ContainingLibrariesVerifier();

   /**
    * Assert that the results of analyzing the libraries (as computed by {#link
    * {@link #verify(LibraryElement)}) were as expected.
    *
    * @param context the analysis context used to get additional information
    */
   protected void assertValid(AnalysisContext context) {
     assertErrors();
     elementVerifier.assertValid();
     staticTypeVerifier.assertResolved();
     resolutionVerifier.assertResolved();
     librariesVerifier.assertValid(context);
   }

   protected void printStatistics() {
     System.out.print("  scan:    ");
     printTime(PerformanceStatistics.scan.getResult());
     System.out.println();

     System.out.print("  parse:   ");
     printTime(PerformanceStatistics.parse.getResult());
     System.out.println();

     System.out.print("  resolve: ");
     printTime(PerformanceStatistics.resolve.getResult());
     System.out.println();

     System.out.print("  errors:  ");
     printTime(PerformanceStatistics.errors.getResult());
     System.out.println();

     System.out.print("  hints:   ");
     printTime(PerformanceStatistics.hints.getResult());
     System.out.println();
   }

   /**
    * Mark the given library as one that should be ignored when validating the libraries that were
    * analyzed.
    *
    * @param library the library to be ignored
    */
   protected void validateSdk() {
     validateSdk = true;
   }

   /**
    * Add all of the errors in the given library and all referenced libraries to the list of errors.
    *
    * @param library the library whose errors are to be added
    * @throws AnalysisException if the errors could not be determined
    */
   protected void verify(LibraryElement library) throws AnalysisException {
     if (library == null || visitedLibraries.contains(library)
         || (!validateSdk && library.getSource().isInSystemLibrary())) {
       return;
     }
     visitedLibraries.add(library);
     library.accept(elementVerifier);
     CompilationUnitElement definingUnit = library.getDefiningCompilationUnit();
     verify(definingUnit);
     librariesVerifier.addLibrary(definingUnit);
     for (CompilationUnitElement part : library.getParts()) {
       verify(part);
       librariesVerifier.addPart(part, definingUnit);
     }
     for (LibraryElement importedLibrary : library.getImportedLibraries()) {
       verify(importedLibrary);
     }
     for (LibraryElement exportedLibrary : library.getExportedLibraries()) {
       verify(exportedLibrary);
     }
   }

   /**
    * Assert that the errors that were reported match the expected behavior of the test.
    */
   private void assertErrors() {
     int size = errorList.size();
     if (size > 0) {
       @SuppressWarnings("resource")
       PrintStringWriter writer = new PrintStringWriter();
       writer.print("Expected 0 errors, found ");
       writer.print(errorList.size());
       writer.print(":");
       int todoCount = countErrorsOfType(TodoCode.TODO);
       size -= todoCount;
       if (size > 128) {
         HashMap<String, Integer> counts = new HashMap<String, Integer>();
         int maxCount = 0;
         for (AnalysisError error : errorList) {
           ErrorCode code = error.getErrorCode();
           String codeName = code.getClass().getSimpleName() + "." + code;
           Integer oldCount = counts.get(codeName);
           int newCount = (oldCount == null) ? 1 : oldCount.intValue() + 1;
           counts.put(codeName, Integer.valueOf(newCount));
           maxCount = Math.max(maxCount, newCount);
         }
         int countWidth = Integer.toString(maxCount).length();
         String format = "%0" + countWidth + "d" + " %s";
         for (Map.Entry<String, Integer> entry : counts.entrySet()) {
           writer.println();
           writer.printf(format, entry.getValue(), entry.getKey());
         }
       } else {
 //        Collections.sort(errorList, AnalysisError.FILE_COMPARATOR);
         Collections.sort(errorList, AnalysisError.ERROR_CODE_COMPARATOR);
         for (AnalysisError error : errorList) {
           Source source = error.getSource();
           ErrorCode code = error.getErrorCode();
           if (code != TodoCode.TODO) {
             int offset = error.getOffset();
             writer.println();
             writer.printf(
                 "%s %s (%d..%d) \"%s\"%s",
                 source == null ? "null" : source.getShortName(),
                 code.getClass().getSimpleName() + "." + code,
                 offset,
                 offset + error.getLength(),
                 error.getMessage(),
                 source == null ? "" : " (" + source.getFullName() + ")");
           }
         }
         if (todoCount > 0) {
           writer.println();
           writer.printf("%d %s", todoCount, TodoCode.TODO);
         }
       }
       Assert.fail(writer.toString());
     }
   }

   /**
    * Return the number of errors with the given error code that were recorded.
    *
    * @param errorCode the error code being searched for
    * @return the number of errors with the given error code
    */
   private int countErrorsOfType(ErrorCode errorCode) {
     int count = 0;
     for (AnalysisError error : errorList) {
       if (error.getErrorCode() == errorCode) {
         count++;
       }
     }
     return count;
   }

   /**
    * Print the given value as a number of milliseconds.
    *
    * @param time the number of milliseconds to be printed
    */
   private void printTime(long time) {
     if (time == 0) {
       System.out.print("0 ms");
     } else {
       System.out.print(time);
       System.out.print(" ms");
       if (time > 60000) {
         long seconds = time / 1000;
         long minutes = seconds / 60;
         seconds -= minutes * 60;
         System.out.print(" (");
         System.out.print(minutes);
         System.out.print(":");
         if (seconds < 10) {
           System.out.print("0");
         }
         System.out.print(seconds);
         System.out.print(")");
       }
     }
   }

   /**
    * Add the errors reported for the given compilation unit to the given list of errors.
    *
    * @param element the compilation unit whose errors are to be added
    * @throws AnalysisException if the errors could not be determined
    */
   private void verify(CompilationUnitElement element) throws AnalysisException {
     LibraryElement library = element.getLibrary();
     AnalysisContext context = library.getContext();
     CompilationUnit unit = context.resolveCompilationUnit(element.getSource(), library);
     AnalysisError[] errors = context.computeErrors(element.getSource());
     if (errors == null) {
       Assert.fail("The compilation unit \"" + element.getSource().getFullName()
           + "\" was not resolved");
     }
     for (AnalysisError error : errors) {
       errorList.add(error);
     }
     unit.accept(staticTypeVerifier);
     unit.accept(resolutionVerifier);
   }
 }
	/*
	* 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
	* or implied. See the License for the specific language governing permissions and limitations under
	* the License.
	*/
	package com.google.dart.engine.integration;

	import com.google.dart.engine.ast.CompilationUnit;
	import com.google.dart.engine.context.AnalysisContext;
	import com.google.dart.engine.context.AnalysisException;
	import com.google.dart.engine.element.CompilationUnitElement;
	import com.google.dart.engine.element.LibraryElement;
	import com.google.dart.engine.error.AnalysisError;
	import com.google.dart.engine.error.ErrorCode;
	import com.google.dart.engine.error.TodoCode;
	import com.google.dart.engine.internal.context.PerformanceStatistics;
	import com.google.dart.engine.internal.resolver.ResolutionVerifier;
	import com.google.dart.engine.internal.resolver.StaticTypeVerifier;
	import com.google.dart.engine.source.Source;
	import com.google.dart.engine.utilities.io.PrintStringWriter;

	import junit.framework.Assert;
	import junit.framework.TestCase;

	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.Map;

	/**
	* The abstract class {@code LibraryAnalysisTest} defines utility methods useful for integration
	* tests that analyze one or more libraries as a single test.
	*/
	public abstract class LibraryAnalysisTest extends TestCase {
	/**
	* A set containing all of the libraries that have been visited as part of verifying the results
	* of analysis.
	*/
	private HashSet<LibraryElement> visitedLibraries = new HashSet<LibraryElement>();

	/**
	* A flag indicating whether libraries that are part of the SDK should be validated.
	*/
	private boolean validateSdk = false;

	/**
	* A list to which all of the errors in the libraries will be added.
	*/
	private ArrayList<AnalysisError> errorList = new ArrayList<AnalysisError>();

	/**
	* The object used to verify that everything that ought to have a static type associated with it
	* has a static type.
	*/
	private StaticTypeVerifier staticTypeVerifier = new StaticTypeVerifier();

	/**
	* The object used to verify that everything that ought to have been resolved was resolved.
	*/
	private ResolutionVerifier resolutionVerifier = new ResolutionVerifier();

	/**
	* The object used to verify that the element structures of the libraries were correctly formed.
	*/
	private ElementStructureVerifier elementVerifier = new ElementStructureVerifier();

	/**
	* The object used to verify that the containing libraries of the sources were correctly computed.
	*/
	private ContainingLibrariesVerifier librariesVerifier = new ContainingLibrariesVerifier();

	/**
	* Assert that the results of analyzing the libraries (as computed by {#link
	* {@link #verify(LibraryElement)}) were as expected.
	*
	* @param context the analysis context used to get additional information
	*/
	protected void assertValid(AnalysisContext context) {
	assertErrors();
	elementVerifier.assertValid();
	staticTypeVerifier.assertResolved();
	resolutionVerifier.assertResolved();
	librariesVerifier.assertValid(context);
	}

	protected void printStatistics() {
	System.out.print(" scan: ");
	printTime(PerformanceStatistics.scan.getResult());
	System.out.println();

	System.out.print(" parse: ");
	printTime(PerformanceStatistics.parse.getResult());
	System.out.println();

	System.out.print(" resolve: ");
	printTime(PerformanceStatistics.resolve.getResult());
	System.out.println();

	System.out.print(" errors: ");
	printTime(PerformanceStatistics.errors.getResult());
	System.out.println();

	System.out.print(" hints: ");
	printTime(PerformanceStatistics.hints.getResult());
	System.out.println();
	}

	/**
	* Mark the given library as one that should be ignored when validating the libraries that were
	* analyzed.
	*
	* @param library the library to be ignored
	*/
	protected void validateSdk() {
	validateSdk = true;
	}

	/**
	* Add all of the errors in the given library and all referenced libraries to the list of errors.
	*
	* @param library the library whose errors are to be added
	* @throws AnalysisException if the errors could not be determined
	*/
	protected void verify(LibraryElement library) throws AnalysisException {
	if (library == null \|\| visitedLibraries.contains(library)
	\|\| (!validateSdk && library.getSource().isInSystemLibrary())) {
	return;
	}
	visitedLibraries.add(library);
	library.accept(elementVerifier);
	CompilationUnitElement definingUnit = library.getDefiningCompilationUnit();
	verify(definingUnit);
	librariesVerifier.addLibrary(definingUnit);
	for (CompilationUnitElement part : library.getParts()) {
	verify(part);
	librariesVerifier.addPart(part, definingUnit);
	}
	for (LibraryElement importedLibrary : library.getImportedLibraries()) {
	verify(importedLibrary);
	}
	for (LibraryElement exportedLibrary : library.getExportedLibraries()) {
	verify(exportedLibrary);
	}
	}

	/**
	* Assert that the errors that were reported match the expected behavior of the test.
	*/
	private void assertErrors() {
	int size = errorList.size();
	if (size > 0) {
	@SuppressWarnings("resource")
	PrintStringWriter writer = new PrintStringWriter();
	writer.print("Expected 0 errors, found ");
	writer.print(errorList.size());
	writer.print(":");
	int todoCount = countErrorsOfType(TodoCode.TODO);
	size -= todoCount;
	if (size > 128) {
	HashMap<String, Integer> counts = new HashMap<String, Integer>();
	int maxCount = 0;
	for (AnalysisError error : errorList) {
	ErrorCode code = error.getErrorCode();
	String codeName = code.getClass().getSimpleName() + "." + code;
	Integer oldCount = counts.get(codeName);
	int newCount = (oldCount == null) ? 1 : oldCount.intValue() + 1;
	counts.put(codeName, Integer.valueOf(newCount));
	maxCount = Math.max(maxCount, newCount);
	}
	int countWidth = Integer.toString(maxCount).length();
	String format = "%0" + countWidth + "d" + " %s";
	for (Map.Entry<String, Integer> entry : counts.entrySet()) {
	writer.println();
	writer.printf(format, entry.getValue(), entry.getKey());
	}
	} else {
	// Collections.sort(errorList, AnalysisError.FILE_COMPARATOR);
	Collections.sort(errorList, AnalysisError.ERROR_CODE_COMPARATOR);
	for (AnalysisError error : errorList) {
	Source source = error.getSource();
	ErrorCode code = error.getErrorCode();
	if (code != TodoCode.TODO) {
	int offset = error.getOffset();
	writer.println();
	writer.printf(
	"%s %s (%d..%d) \"%s\"%s",
	source == null ? "null" : source.getShortName(),
	code.getClass().getSimpleName() + "." + code,
	offset,
	offset + error.getLength(),
	error.getMessage(),
	source == null ? "" : " (" + source.getFullName() + ")");
	}
	}
	if (todoCount > 0) {
	writer.println();
	writer.printf("%d %s", todoCount, TodoCode.TODO);
	}
	}
	Assert.fail(writer.toString());
	}
	}

	/**
	* Return the number of errors with the given error code that were recorded.
	*
	* @param errorCode the error code being searched for
	* @return the number of errors with the given error code
	*/
	private int countErrorsOfType(ErrorCode errorCode) {
	int count = 0;
	for (AnalysisError error : errorList) {
	if (error.getErrorCode() == errorCode) {
	count++;
	}
	}
	return count;
	}

	/**
	* Print the given value as a number of milliseconds.
	*
	* @param time the number of milliseconds to be printed
	*/
	private void printTime(long time) {
	if (time == 0) {
	System.out.print("0 ms");
	} else {
	System.out.print(time);
	System.out.print(" ms");
	if (time > 60000) {
	long seconds = time / 1000;
	long minutes = seconds / 60;
	seconds -= minutes * 60;
	System.out.print(" (");
	System.out.print(minutes);
	System.out.print(":");
	if (seconds < 10) {
	System.out.print("0");
	}
	System.out.print(seconds);
	System.out.print(")");
	}
	}
	}

	/**
	* Add the errors reported for the given compilation unit to the given list of errors.
	*
	* @param element the compilation unit whose errors are to be added
	* @throws AnalysisException if the errors could not be determined
	*/
	private void verify(CompilationUnitElement element) throws AnalysisException {
	LibraryElement library = element.getLibrary();
	AnalysisContext context = library.getContext();
	CompilationUnit unit = context.resolveCompilationUnit(element.getSource(), library);
	AnalysisError[] errors = context.computeErrors(element.getSource());
	if (errors == null) {
	Assert.fail("The compilation unit \"" + element.getSource().getFullName()
	+ "\" was not resolved");
	}
	for (AnalysisError error : errors) {
	errorList.add(error);
	}
	unit.accept(staticTypeVerifier);
	unit.accept(resolutionVerifier);
	}
	}