/*
* 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.tools.apichecker;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.NotFoundException;
import com.google.gwt.dev.javac.testing.impl.StaticJavaResource;
import com.google.gwt.dev.resource.Resource;
import com.google.gwt.dev.util.log.AbstractTreeLogger;
import com.google.gwt.dev.util.log.PrintWriterTreeLogger;
import junit.framework.TestCase;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
/**
*
* Test 2 ApiContainers for compatibility
*
* test compatibility output if returnType changes, parameters change, method
* overload compatibility, exception compatibility; abstract added, final added
* to both ApiClass, apiMethods.
*
* test white-list support.
*
* TODO(amitmanjhi): (1) Re-factor this code as much as possible into smaller
* separate components similar to the ApiCompatibilityUnit class. (2) Use
* MockApiElement instead of String comparisons.
*/
public class ApiCompatibilityTest extends TestCase {
// These cups are slightly different from the cups in ApiContainerTest
private static final boolean DEBUG = false;
private static StaticJavaResource[] getScuArray() {
return new StaticJavaResource[] {
new StaticJavaResource("test.apicontainer.ApiClass", getSourceForApiClass()),
new StaticJavaResource("test.apicontainer.NonApiClass", getSourceForNonApiClass()),
new StaticJavaResource("test.nonapipackage.TestClass", getSourceForTestClass()),
new StaticJavaResource("java.lang.Object", getSourceForObject()),
new StaticJavaResource("java.lang.Throwable", getSourceForThrowable()),
new StaticJavaResource("test.apicontainer.OneMoreApiClass", getSourceForOneMoreApiClass()),
new StaticJavaResource("java.lang.RuntimeException", getSourceForRuntimeException()),};
}
private static String getSourceForApiClass() {
StringBuffer sb = new StringBuffer();
sb.append("package test.apicontainer;\n");
sb.append("public class ApiClass extends NonApiClass {\n");
sb.append("\tpublic void apiMethod() { };\n");
sb.append("\tpublic void checkParametersAndReturnTypes(java.lang.Object x) throws java.lang.Throwable { };\n");
sb.append("\tpublic final void checkParametersAndReturnTypesFinalVersion(java.lang.Object x) throws java.lang.Throwable { };\n");
sb.append("};\n");
return sb.toString();
}
private static String getSourceForNonApiClass() {
StringBuffer sb = new StringBuffer();
sb.append("package test.apicontainer;\n");
sb.append("class NonApiClass extends java.lang.Object {\n");
sb.append("\tpublic void methodInNonApiClass(ApiClassInNonApiClass o) { };\n");
sb.append("\tpublic void methodInNonApiClass(NonApiClass t) { };\n");
sb.append("\tpublic int fieldInNonApiClass = 3;\n");
sb.append("\tprotected abstract class ApiClassInNonApiClass {\n");
sb.append("\tprotected ApiClassInNonApiClass() { }\n");
sb.append("\t}\n");
sb.append("}\n");
return sb.toString();
}
private static String getSourceForObject() {
StringBuffer sb = new StringBuffer();
sb.append("package java.lang;\n");
sb.append("public class Object {\n");
sb.append("\tpublic void apiMethod() { }\n");
sb.append("\tprotected void checkOverloadedAndOverridableDetection(java.lang.Object b) { }\n");
sb.append("\tprotected final void checkOverloadedMethodAccounted(java.lang.Object b) { }\n");
sb.append("\tprivate void internalMethod() { }\n");
sb.append("\tprotected final void protectedMethod() { }\n");
sb.append("\tpublic final int apiField = 0;\n");
sb.append("\tprivate int internalField = 0;\n");
sb.append("\tprotected static int protectedField=2;\n");
sb.append("}\n");
return sb.toString();
}
private static String getSourceForOneMoreApiClass() {
StringBuffer sb = new StringBuffer();
sb.append("package test.apicontainer;\n");
sb.append("public class OneMoreApiClass extends java.lang.Object {\n");
sb.append("\tprotected void checkOverloadedAndOverridableDetection(test.apicontainer.OneMoreApiClass b) { }\n");
sb.append("\tprotected final void checkOverloadedMethodAccounted(test.apicontainer.ApiClass b) throws java.lang.Throwable { }\n");
sb.append("\tpublic void testUncheckedExceptions() throws RuntimeException { }\n");
sb.append("};\n");
return sb.toString();
}
private static String getSourceForRuntimeException() {
StringBuffer sb = new StringBuffer();
sb.append("package java.lang;\n");
sb.append("public class RuntimeException extends Throwable {\n");
sb.append("}\n");
return sb.toString();
}
private static String getSourceForTestClass() {
StringBuffer sb = new StringBuffer();
sb.append("package test.nonapipackage;\n");
sb.append("class TestClass extends java.lang.Object {\n");
sb.append("\tpublic void method() { }\n");
sb.append("}\n");
return sb.toString();
}
private static String getSourceForThrowable() {
StringBuffer sb = new StringBuffer();
sb.append("package java.lang;\n");
sb.append("public class Throwable extends Object {\n");
sb.append("}\n");
return sb.toString();
}
ApiContainer api1 = null;
ApiContainer api2 = null;
ApiContainer apiSameAs1 = null;
@Override
public void setUp() throws UnableToCompleteException {
AbstractTreeLogger logger = new PrintWriterTreeLogger();
logger.setMaxDetail(TreeLogger.ERROR);
api1 =
new ApiContainer("Api1", new HashSet<Resource>(Arrays
.asList(ApiContainerTest.getScuArray())), new HashSet<String>(), logger);
apiSameAs1 =
new ApiContainer("ApiSameAs1", new HashSet<Resource>(Arrays.asList(ApiContainerTest
.getScuArray())), new HashSet<String>(), logger);
api2 =
new ApiContainer("Api2", new HashSet<Resource>(Arrays.asList(getScuArray())),
new HashSet<String>(), logger);
}
// setup is called before every test*. To avoid the overhead of setUp() each
// time, test everything together.
public void testEverything() throws NotFoundException {
checkBasicStuff();
checkWhiteList();
}
private void checkBasicStuff() throws NotFoundException {
HashSet<String> hashSet = new HashSet<String>();
assertEquals(0, ApiCompatibilityChecker.getApiDiff(api1, apiSameAs1, hashSet).size());
ApiDiffGenerator apiDiff = new ApiDiffGenerator(api2, api1);
String strWithDuplicates =
getStringRepresentation(ApiCompatibilityChecker.getApiDiff(apiDiff, hashSet,
!ApiCompatibilityChecker.FILTER_DUPLICATES));
if (DEBUG) {
System.out.println("computing apiDiff, now with duplicates");
System.out.println(strWithDuplicates);
}
String strWithoutDuplicates =
getStringRepresentation(ApiCompatibilityChecker.getApiDiff(apiDiff, hashSet,
ApiCompatibilityChecker.FILTER_DUPLICATES));
if (DEBUG) {
System.out.println("computing apiDiff, now without duplicates");
System.out.println(strWithoutDuplicates);
}
String delimiter = ApiDiffGenerator.DELIMITER;
// test if missing packages are reported correctly
String statusString = "java.newpackage" + delimiter + ApiChange.Status.MISSING;
assertEquals(1, countPresence(statusString, strWithDuplicates));
assertEquals(1, countPresence(statusString, strWithoutDuplicates));
// test if missing classes are reported correctly
assertEquals(1, countPresence("test.apicontainer.NonApiClass.AnotherApiClassInNonApiClass"
+ delimiter + ApiChange.Status.MISSING, strWithoutDuplicates));
// test if modifier changes of a class are reported
assertEquals(1, countPresence("test.apicontainer.NonApiClass.ApiClassInNonApiClass" + delimiter
+ ApiChange.Status.ABSTRACT_ADDED, strWithoutDuplicates));
// test if methods are still reported even if class becomes abstract (as
// long as it is sub-classable)
assertEquals(0, countPresence(
"test.apicontainer.NonApiClass.ApiClassInNonApiClass::ApiClassInNonApiClass()" + delimiter
+ ApiChange.Status.MISSING, strWithoutDuplicates));
assertEquals(0, countPresence(
"test.apicontainer.NonApiClass.ApiClassInNonApiClass::protectedMethod()" + delimiter
+ ApiChange.Status.MISSING, strWithoutDuplicates));
// test if modifier changes of fields and methods are reported
assertEquals(1, countPresence("java.lang.Object::apiField" + delimiter
+ ApiChange.Status.FINAL_ADDED, strWithoutDuplicates));
assertEquals(1, countPresence("java.lang.Object::protectedMethod()" + delimiter
+ ApiChange.Status.FINAL_ADDED, strWithoutDuplicates));
// test if duplicates are weeded out from intersecting methods
assertEquals(4, countPresence("protectedMethod()" + delimiter + ApiChange.Status.FINAL_ADDED,
strWithDuplicates));
assertEquals(1, countPresence("protectedMethod()" + delimiter + ApiChange.Status.FINAL_ADDED,
strWithoutDuplicates));
// test if duplicates are weeded out from missing fields
assertEquals(4, countPresence("apiFieldWillBeMissing" + delimiter + ApiChange.Status.MISSING,
strWithDuplicates));
assertEquals(1, countPresence("apiFieldWillBeMissing" + delimiter + ApiChange.Status.MISSING,
strWithoutDuplicates));
// test error in non-final version
String nonFinalMethodSignature = "checkParametersAndReturnTypes(Ltest/apicontainer/ApiClass;)";
for (ApiChange.Status status : new ApiChange.Status[] {
ApiChange.Status.OVERRIDABLE_METHOD_ARGUMENT_TYPE_CHANGE,
ApiChange.Status.OVERRIDABLE_METHOD_EXCEPTION_TYPE_CHANGE,
ApiChange.Status.OVERRIDABLE_METHOD_RETURN_TYPE_CHANGE}) {
assertEquals(1, countPresence(nonFinalMethodSignature + delimiter + status,
strWithoutDuplicates));
}
// test return type and exception type error in final version
String finalMethodSignature =
"checkParametersAndReturnTypesFinalVersion(Ltest/apicontainer/ApiClass;)";
assertEquals(1, countPresence(finalMethodSignature + delimiter
+ ApiChange.Status.RETURN_TYPE_ERROR, strWithoutDuplicates));
assertEquals(1, countPresence(finalMethodSignature + delimiter
+ ApiChange.Status.EXCEPTION_TYPE_ERROR, strWithoutDuplicates));
// checking if changes in parameter types were okay
assertEquals(2, countPresence(finalMethodSignature, strWithoutDuplicates));
// test method_overloading
finalMethodSignature = "methodInNonApiClass(Ltest/apicontainer/NonApiClass;)";
assertEquals(1, countPresence(finalMethodSignature + delimiter
+ ApiChange.Status.OVERLOADED_METHOD_CALL, strWithoutDuplicates));
// test unchecked exceptions
assertEquals(0, countPresence("testUncheckedExceptions", strWithoutDuplicates));
// test overloaded and overridable detection
String methodSignature =
"test.apicontainer.OneMoreApiClass::checkOverloadedAndOverridableDetection(Ljava/lang/Object;)";
for (ApiChange.Status status : new ApiChange.Status[] {
ApiChange.Status.OVERRIDABLE_METHOD_ARGUMENT_TYPE_CHANGE,
ApiChange.Status.OVERRIDABLE_METHOD_EXCEPTION_TYPE_CHANGE,
ApiChange.Status.OVERRIDABLE_METHOD_RETURN_TYPE_CHANGE}) {
assertEquals(0, countPresence(methodSignature + delimiter + status, strWithoutDuplicates));
}
// the method should be satisfied by the method in the super-class
methodSignature =
"test.apicontainer.OneMoreApiClass::checkOverloadedMethodAccounted(Ltest/apicontainer/OneMoreApiClass;)";
assertEquals(0, countPresence(methodSignature + delimiter + ApiChange.Status.MISSING,
strWithoutDuplicates));
// the method should throw unchecked exceptions error
methodSignature =
"test.apicontainer.OneMoreApiClass::checkOverloadedMethodAccounted(Ljava/lang/Object;)";
assertEquals(1, countPresence(methodSignature + delimiter
+ ApiChange.Status.EXCEPTION_TYPE_ERROR, strWithoutDuplicates));
}
private void checkWhiteList() throws NotFoundException {
ApiDiffGenerator apiDiff = new ApiDiffGenerator(api2, api1);
boolean removeDuplicates = false;
String whiteList = "java.newpackage" + ApiDiffGenerator.DELIMITER + ApiChange.Status.MISSING;
HashSet<String> hashSet = new HashSet<String>();
hashSet.add(whiteList);
String strWithoutDuplicates =
getStringRepresentation(ApiCompatibilityChecker.getApiDiff(apiDiff, hashSet,
!removeDuplicates));
// test if missing packages are reported correctly
assertEquals(0, countPresence(whiteList, strWithoutDuplicates));
}
private int countPresence(String needle, String hay) {
int count = 0;
int needleLength = needle.length();
int index = -needleLength;
while ((index = hay.indexOf(needle, index + needleLength)) != -1) {
count++;
}
return count;
}
private String getStringRepresentation(Collection<ApiChange> collection) {
StringBuffer sb = new StringBuffer();
for (ApiChange apiChange : collection) {
sb.append(apiChange);
sb.append("\n");
}
return sb.toString();
}
}
// abstract methods can't be static
class TestAA {
static int j = 10;
static void printX() {
System.err.println("2");
}
int i = 5;
private TestAA() {
}
}
class TestAB {
static void test() {
TestAA.printX();
}
}