/*
* Copyright 2008 Google Inc.
*
* Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
*
* 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.gwt.dev.javac;
import com.google.gwt.dev.MinimalRebuildCache;
import com.google.gwt.dev.javac.Dependencies.Ref;
import com.google.gwt.dev.javac.testing.impl.JavaResourceBase;
import com.google.gwt.dev.javac.testing.impl.MockJavaResource;
import com.google.gwt.dev.javac.testing.impl.MockResourceOracle;
import com.google.gwt.dev.jjs.SourceOrigin;
import com.google.gwt.dev.js.JsParser;
import com.google.gwt.dev.js.JsSourceGenerationVisitor;
import com.google.gwt.dev.js.ast.JsFunction;
import com.google.gwt.dev.js.ast.JsRootScope;
import com.google.gwt.dev.js.ast.JsStatement;
import com.google.gwt.dev.js.ast.JsVisitor;
import com.google.gwt.dev.util.DefaultTextOutput;
import com.google.gwt.dev.util.TextOutput;
import com.google.gwt.dev.util.Util;
import com.google.gwt.dev.util.collect.Lists;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.StringReader;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Tests {@link CompilationState}.
*/
public class CompilationStateTest extends CompilationStateTestBase {
private static final MockJavaResource FOO_DIFF_API =
new MockJavaResource("test.Foo") {
@Override
public CharSequence getContent() {
StringBuilder code = new StringBuilder();
code.append("package test;\n");
code.append("public class Foo {\n");
code.append(" public String value() { return \"Foo\"; }\n");
code.append(" public String value2() { return \"Foo2\"; }\n");
code.append("}\n");
return code;
}
};
private static final MockJavaResource FOO_SAME_API =
new MockJavaResource("test.Foo") {
@Override
public CharSequence getContent() {
StringBuilder code = new StringBuilder();
code.append("package test;\n");
code.append("public class Foo {\n");
code.append(" public String value() { return \"Foo2\"; }\n");
code.append("}\n");
return code;
}
};
private static String parseJs(String js) throws Exception {
List<JsStatement> parsed =
JsParser.parse(SourceOrigin.UNKNOWN, JsRootScope.INSTANCE,
new StringReader(js));
TextOutput text = new DefaultTextOutput(false);
JsVisitor generator = new JsSourceGenerationVisitor(text);
generator.acceptList(parsed);
return text.toString();
}
public void testAddGeneratedCompilationUnit_incremental() {
checkAddGeneratedCompilationUnit(true);
}
public void testAddGeneratedCompilationUnit_regular() {
checkAddGeneratedCompilationUnit(false);
}
private void checkAddGeneratedCompilationUnit(boolean incremental) {
compilerContext.getOptions().setIncrementalCompileEnabled(incremental);
MinimalRebuildCache minimalRebuildCache = compilerContext.getMinimalRebuildCache();
// Compile and ensure that not-yet-generated class Foo is not seen.
validateCompilationState();
assertFalse(minimalRebuildCache.getModifiedCompilationUnitNames().contains("test.Foo"));
// Add a generated unit and ensure it shows up as a new modified unit.
addGeneratedUnits(JavaResourceBase.FOO);
validateCompilationState(Shared.getTypeName(JavaResourceBase.FOO));
assertEquals(incremental,
minimalRebuildCache.getModifiedCompilationUnitNames().contains("test.Foo"));
rebuildCompilationState();
validateCompilationState();
}
/* test that a generated unit, if unchanged, is reused */
public void testCaching() {
testCaching(JavaResourceBase.FOO);
}
/* test that multiple generated units, if unchanged, are reused */
public void testCachingOfMultipleUnits() {
testCaching(JavaResourceBase.BAR, JavaResourceBase.FOO);
}
public void testCompileError() {
oracle.add(JavaResourceBase.BAR);
rebuildCompilationState();
CompilationUnit badUnit =
state.getCompilationUnitMap().get(
Shared.getTypeName(JavaResourceBase.BAR));
assertTrue(badUnit.isError());
Set<CompilationUnit> goodUnits =
new HashSet<CompilationUnit>(state.getCompilationUnits());
goodUnits.remove(badUnit);
assertUnitsChecked(goodUnits);
}
public void testCompileWithGeneratedUnits() {
assertUnitsChecked(state.getCompilationUnits());
addGeneratedUnits(JavaResourceBase.FOO);
assertUnitsChecked(state.getCompilationUnits());
}
public void testCompileWithGeneratedUnitsError() {
assertUnitsChecked(state.getCompilationUnits());
addGeneratedUnits(JavaResourceBase.BAR);
CompilationUnit badUnit =
state.getCompilationUnitMap().get(
Shared.getTypeName(JavaResourceBase.BAR));
assertTrue(badUnit.isError());
Set<CompilationUnit> goodUnits =
new HashSet<CompilationUnit>(state.getCompilationUnits());
goodUnits.remove(badUnit);
assertUnitsChecked(goodUnits);
}
public void testCompileWithGeneratedUnitsErrorAndDepedentGeneratedUnit() {
assertUnitsChecked(state.getCompilationUnits());
MockJavaResource badFoo =
new MockJavaResource(Shared.getTypeName(JavaResourceBase.FOO)) {
@Override
public CharSequence getContent() {
return "compilation error LOL!";
}
};
oracle.add(badFoo);
rebuildCompilationState();
addGeneratedUnits(JavaResourceBase.BAR);
CompilationUnit badUnit =
state.getCompilationUnitMap().get(Shared.getTypeName(badFoo));
assertTrue(badUnit.isError());
CompilationUnit invalidUnit =
state.getCompilationUnitMap().get(
Shared.getTypeName(JavaResourceBase.BAR));
assertTrue(invalidUnit.isError());
Set<CompilationUnit> goodUnits =
new HashSet<CompilationUnit>(state.getCompilationUnits());
goodUnits.remove(badUnit);
goodUnits.remove(invalidUnit);
assertUnitsChecked(goodUnits);
}
/*
* test if things work correctly when a generated unit can't be reused, but
* another generated unit it depends on can be reused
*/
public void testComplexCacheInvalidation() {
testCachingOverMultipleRefreshes(new MockJavaResource[]{
JavaResourceBase.FOO, JavaResourceBase.BAR},
new MockJavaResource[]{
JavaResourceBase.FOO,
new TweakedMockJavaResource(JavaResourceBase.BAR)},
Collections.singleton(JavaResourceBase.FOO.getTypeName()));
}
public void testInitialization() {
assertUnitsChecked(state.getCompilationUnits());
}
public void testInvalidation() {
testCachingOverMultipleRefreshes(
new MockJavaResource[]{JavaResourceBase.FOO},
new MockJavaResource[]{new TweakedMockJavaResource(JavaResourceBase.FOO)},
Collections.<String> emptySet());
}
public void testInvalidationNonstructuralDep() {
testCachingOverMultipleRefreshes(new MockJavaResource[]{
JavaResourceBase.FOO, JavaResourceBase.BAR}, new MockJavaResource[]{
FOO_SAME_API, JavaResourceBase.BAR},
Collections.singleton(JavaResourceBase.BAR.getTypeName()));
}
public void testInvalidationOfMultipleUnits() {
testCachingOverMultipleRefreshes(new MockJavaResource[]{
JavaResourceBase.FOO, JavaResourceBase.BAR}, new MockJavaResource[]{
new TweakedMockJavaResource(JavaResourceBase.FOO),
new TweakedMockJavaResource(JavaResourceBase.BAR)},
Collections.<String> emptySet());
}
public void testInvalidationStructuralDep() {
testCachingOverMultipleRefreshes(new MockJavaResource[]{
JavaResourceBase.FOO, JavaResourceBase.BAR}, new MockJavaResource[]{
FOO_DIFF_API, JavaResourceBase.BAR}, Collections.<String> emptySet());
}
public void testInvalidationWhenSourceUnitsChange() {
/*
* Steps: (i) Check compilation state. (ii) Add generated units. (iii)
* Change unit in source oracle. (iv) Refresh oracle. (v) Add same generated
* units. (v) Check that there is no reuse.
*/
validateCompilationState();
oracle.add(JavaResourceBase.FOO);
rebuildCompilationState();
// add generated units
addGeneratedUnits(JavaResourceBase.BAR);
assertUnitsChecked(state.getCompilationUnits());
CompilationUnit oldBar =
state.getCompilationUnitMap().get(JavaResourceBase.BAR.getTypeName());
assertNotNull(oldBar);
// change unit in source oracle
oracle.replace(FOO_DIFF_API);
rebuildCompilationState();
/*
* Add same generated units. Verify that the original units are not used.
*/
addGeneratedUnits(JavaResourceBase.BAR);
assertUnitsChecked(state.getCompilationUnits());
CompilationUnit newBar =
state.getCompilationUnitMap().get(JavaResourceBase.BAR.getTypeName());
assertNotNull(newBar);
assertNotSame(oldBar, newBar);
}
public void testMethodArgs() {
MockJavaResource resource = new MockJavaResource("test.MethodArgsTest") {
@Override
public CharSequence getContent() {
StringBuilder code = new StringBuilder();
code.append("package test;\n");
code.append("public abstract class MethodArgsTest {\n");
code.append(" public abstract void anAbstractMethod(String aArg1);\n");
code.append(" public native void aNativeMethod(String nArg1, int nArg2);\n");
code.append(" public void aMethod(String mArg1, int mArg2, char mArg3) {}\n");
code.append(" public void aNoArgMethod() {}\n");
code.append("}\n");
return code;
}
};
validateCompilationState();
oracle.add(resource);
rebuildCompilationState();
validateCompilationState();
Map<String, CompilationUnit> unitMap = state.getCompilationUnitMap();
MethodArgNamesLookup methodArgs =
unitMap.get(Shared.getTypeName(resource)).getMethodArgs();
String[] methods = methodArgs.getMethods();
assertEquals(3, methods.length);
Arrays.sort(methods);
assertEquals("test.MethodArgsTest.aMethod(Ljava/lang/String;IC)V",
methods[0]);
assertEquals("test.MethodArgsTest.aNativeMethod(Ljava/lang/String;I)V",
methods[1]);
assertEquals("test.MethodArgsTest.anAbstractMethod(Ljava/lang/String;)V",
methods[2]);
String[] names;
names = methodArgs.lookup(methods[0]);
assertEquals(3, names.length);
assertEquals("mArg1", names[0]);
assertEquals("mArg2", names[1]);
assertEquals("mArg3", names[2]);
names = methodArgs.lookup(methods[1]);
assertEquals(2, names.length);
assertEquals("nArg1", names[0]);
assertEquals("nArg2", names[1]);
names = methodArgs.lookup(methods[2]);
assertEquals(1, names.length);
assertEquals("aArg1", names[0]);
}
public void testSerializeCompilationUnit() throws Exception {
MockJavaResource resource = new MockJavaResource("test.SerializationTest") {
@Override
public CharSequence getContent() {
StringBuilder code = new StringBuilder();
code.append("package test;\n");
code.append("public abstract class SerializationTest {\n");
code.append(" public static native boolean getTrue() /*-{ return true; }-*/;\n");
code.append(" public abstract String methodArgsTest(int arg1, Object arg2);");
code.append(" public final String toString() { return \"SerializationTest\"; }\n");
code.append("}\n");
return code;
}
};
String resourceTypeName = Shared.getTypeName(resource);
validateCompilationState();
oracle.add(resource);
rebuildCompilationState();
validateCompilationState();
Map<String, CompilationUnit> unitMap = state.getCompilationUnitMap();
validateSerializedTestUnit(resource, unitMap.get(resourceTypeName));
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
for (CompilationUnit unit : unitMap.values()) {
Util.writeObjectToStream(outputStream, unitMap.get(unit.getTypeName()));
}
int numUnits = unitMap.size();
byte[] streamData = outputStream.toByteArray();
ByteArrayInputStream inputStream = new ByteArrayInputStream(streamData);
Map<String, CompilationUnit> newUnitMap =
new HashMap<String, CompilationUnit>();
for (int i = 0; i < numUnits; i++) {
CompilationUnit unit =
Util.readStreamAsObject(inputStream, CompilationUnit.class);
newUnitMap.put(unit.getTypeName(), unit);
}
// Validate all deserialized units against the original units
assertEquals(unitMap.size(), newUnitMap.size());
for (CompilationUnit unit : unitMap.values()) {
CompilationUnit newUnit = newUnitMap.get(unit.getTypeName());
validateSerializedUnit(unit, newUnit);
}
// Validate the SerializationTest resource with a specific test.
validateSerializedTestUnit(resource, newUnitMap.get(resourceTypeName));
}
public void testSourceOracleAdd() {
validateCompilationState();
int size = state.getCompilationUnits().size();
oracle.add(JavaResourceBase.FOO);
rebuildCompilationState();
assertEquals(size + 1, state.getCompilationUnits().size());
validateCompilationState();
}
public void testSourceOracleBasic() {
validateCompilationState();
}
public void testSourceOracleEmpty() {
oracle = new MockResourceOracle();
rebuildCompilationState();
validateCompilationState();
}
public void testSourceOracleRemove() {
validateCompilationState();
int size = state.getCompilationUnits().size();
oracle.remove(JavaResourceBase.MAP.getPath());
rebuildCompilationState();
assertEquals(size - 1, state.getCompilationUnits().size());
validateCompilationState();
}
public void testSourceOracleReplace() {
validateCompilationState();
int size = state.getCompilationUnits().size();
oracle.replace(new TweakedMockJavaResource(JavaResourceBase.OBJECT));
rebuildCompilationState();
assertEquals(size, state.getCompilationUnits().size());
validateCompilationState();
}
public void testSourceOracleReplaceWithSame() {
validateCompilationState();
int size = state.getCompilationUnits().size();
oracle.replace(JavaResourceBase.OBJECT);
rebuildCompilationState();
assertEquals(size, state.getCompilationUnits().size());
validateCompilationState();
}
private void testCaching(MockJavaResource... resources) {
Set<String> reusedTypes = new HashSet<String>();
for (MockJavaResource resource : resources) {
reusedTypes.add(resource.getTypeName());
}
testCachingOverMultipleRefreshes(resources, resources, reusedTypes);
}
/**
* Test caching logic for generated units during refreshes. Steps:
* <ol>
* <li>Verify that there were no generated units before</li>
* <li>Add 'initialSet' generatedUnits over a refresh cycle</li>
* <li>Add 'updatedSet' generatedUnits over a refresh cycle</li>
* <li>Add 'updatedSet' generatedUnits over the second refresh cycle</li>
* </ol>
*
* @param initialSet CompilationUnits that are generated the first time.
* @param updatedSet CompilationUnits that are generated the next time.
* @param reusedTypes Main type of the units that can be reused between the
* initialSet and updatedSet.
*/
private void testCachingOverMultipleRefreshes(MockJavaResource[] initialSet,
MockJavaResource[] updatedSet, Set<String> reusedTypes) {
// Add 'initialSet' generatedUnits on the first cycle.
rebuildCompilationState();
assertEquals(oracle.getResources().size(),
state.getCompilationUnits().size());
addGeneratedUnits(initialSet);
Map<String, CompilationUnit> units1 =
new HashMap<String, CompilationUnit>(state.getCompilationUnitMap());
assertEquals(oracle.getResources().size() + initialSet.length,
units1.size());
assertUnitsChecked(units1.values());
// Add 'updatedSet' generatedUnits on the second cycle.
rebuildCompilationState();
assertEquals(oracle.getResources().size(), state.getCompilationUnits().size());
addGeneratedUnits(updatedSet);
Map<String, CompilationUnit> units2 =
new HashMap<String, CompilationUnit>(state.getCompilationUnitMap());
assertEquals(oracle.getResources().size() + updatedSet.length, units2.size());
assertUnitsChecked(units2.values());
// Can't make assertions about modified compilation unit names here because the
// CompilationUnitInvalidator and staleness checking in the MinimalRebuildCache have different
// semantics.
// Validate that only 'reusedTypes' are reused.
for (MockJavaResource resource : updatedSet) {
String typeName = resource.getTypeName();
if (reusedTypes.contains(typeName)) {
assertSame(units1.get(typeName), units2.get(typeName));
} else {
assertNotSame(units1.get(typeName), units2.get(typeName));
}
}
// Add 'updatedSet' generatedUnits on the third cycle.
rebuildCompilationState();
assertEquals(oracle.getResources().size(),
state.getCompilationUnits().size());
addGeneratedUnits(updatedSet);
Map<String, CompilationUnit> units3 =
new HashMap<String, CompilationUnit>(state.getCompilationUnitMap());
assertEquals(oracle.getResources().size() + updatedSet.length,
units3.size());
assertUnitsChecked(units3.values());
// Validate that all generatedUnits are reused.
for (MockJavaResource resource : updatedSet) {
String typeName = resource.getTypeName();
assertSame(units2.get(typeName), units3.get(typeName));
}
}
private void validateSerializedTestUnit(MockJavaResource resource,
CompilationUnit unit) throws Exception {
assertNotNull(unit);
assertEquals(resource.getLastModified(), unit.getLastModified());
// dependencies
Dependencies deps = unit.getDependencies();
assertObjectInDeps(deps.qualified, deps.simple, "java.lang.Object",
"Object");
assertObjectInDeps(deps.qualified, deps.simple, "java.lang.String",
"String");
assertObjectInDeps(deps.qualified, deps.simple, "test.SerializationTest",
"SerializationTest");
// method args lookup
MethodArgNamesLookup lookup = unit.getMethodArgs();
String methods[] = lookup.getMethods();
assertEquals(1, methods.length);
assertEquals(
"test.SerializationTest.methodArgsTest(ILjava/lang/Object;)Ljava/lang/String;",
methods[0]);
// JSNI methods
List<JsniMethod> jsniMethods = unit.getJsniMethods();
assertEquals(1, jsniMethods.size());
JsniMethod jsniMethod = jsniMethods.get(0);
String[] paramNames = jsniMethod.paramNames();
assertEquals(0, paramNames.length);
assertEquals("@test.SerializationTest::getTrue()", jsniMethod.name());
JsFunction jsniFunction = jsniMethod.function();
String origFunction = parseJs("function() { return true; }");
String newFunction = parseJs("function() " + jsniFunction.getBody().toSource());
assertEquals(origFunction, newFunction);
// Compiled classes
List<CompiledClass> compiledClasses =
Lists.create(unit.getCompiledClasses());
assertEquals(1, compiledClasses.size());
CompiledClass compiledClass = compiledClasses.get(0);
byte[] byteCode = compiledClass.getBytes();
assertNotNull(byteCode);
assertEquals("test", compiledClass.getPackageName());
assertEquals("test/SerializationTest", compiledClass.getInternalName());
assertSame(unit, compiledClass.getUnit());
}
private void assertObjectInDeps(Map<String, Ref> qualified,
Map<String, Ref> simple, String qualifiedName, String simpleName) {
Ref qualifiedRef = qualified.get(qualifiedName);
assertNotNull(qualifiedRef);
assertEquals(qualifiedName, qualifiedRef.getInternalName().replace("/", "."));
Ref simpleRef = simple.get(simpleName);
assertNotNull(simpleRef);
assertEquals(qualifiedName,simpleRef.getInternalName().replace("/", "."));
}
private void validateSerializedUnit(CompilationUnit originalUnit,
CompilationUnit newUnit) throws Exception {
// Compare the compiled classes
Map<String, CompiledClass> origMap = new HashMap<String, CompiledClass>();
for (CompiledClass cc : originalUnit.getCompiledClasses()) {
origMap.put(cc.getInternalName(), cc);
}
Map<String, CompiledClass> newMap = new HashMap<String, CompiledClass>();
for (CompiledClass cc : newUnit.getCompiledClasses()) {
newMap.put(cc.getInternalName(), cc);
}
assertEquals(origMap.size(), newMap.size());
for (String name : origMap.keySet()) {
assertEquals(name, newMap.get(name).getInternalName());
}
// Compare the dependencies
Map<String, Ref> origQualified = originalUnit.getDependencies().qualified;
Map<String, Ref> newQualified = newUnit.getDependencies().qualified;
for (String name : origQualified.keySet()) {
Ref origRef = origQualified.get(name);
Ref newRef = newQualified.get(name);
if (origRef == null) {
assertNull(newRef);
} else {
assertNotNull(newRef);
assertEquals(origRef.getSignatureHash(), newRef.getSignatureHash());
}
}
// Compare JSNI Methods
List<JsniMethod> origJsniMethods = originalUnit.getJsniMethods();
Map<String, JsniMethod> newJsniMethods = new HashMap<String, JsniMethod>();
for (JsniMethod jsniMethod : newUnit.getJsniMethods()) {
newJsniMethods.put(jsniMethod.name(), jsniMethod);
}
for (JsniMethod origMethod : origJsniMethods) {
JsniMethod newMethod = newJsniMethods.get(origMethod.name());
assertNotNull(newMethod);
assertEquals(origMethod.paramNames().length,
newMethod.paramNames().length);
for (int i = 0; i < origMethod.paramNames().length; i++) {
assertEquals(origMethod.paramNames()[i], newMethod.paramNames()[i]);
}
assertEquals(parseJs("function() " + origMethod.function().getBody()),
parseJs("function() " + newMethod.function().getBody()));
// Need to test deserialization of origMethod.function()?
}
}
/**
* Java resource that modifies its content with a terminating newline.
*/
public static class TweakedMockJavaResource extends MockJavaResource {
private MockJavaResource original;
public TweakedMockJavaResource(MockJavaResource original) {
super(original.getTypeName());
this.original = original;
}
@Override
public CharSequence getContent() {
return original.getContent() + "\n";
}
}
}