/*
* 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);
}
}