/*
* 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.UnableToCompleteException;
import com.google.gwt.core.ext.typeinfo.JAbstractMethod;
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.HashSet;
import java.util.Set;
/**
* Test {@link ApiContainer}.
*/
public class ApiContainerTest extends TestCase {
class TestA {
public TestA(String args) {
}
protected TestA(TestA a) {
}
public String valueOf(Object o) {
return "a";
}
public String valueOf(String s) {
return "";
}
}
class TestB extends TestA {
public TestB(TestA a) {
super(a);
}
public void main(String args[]) {
TestA x1 = new TestA("test");
x1.valueOf("ab");
TestB x2 = new TestB(x1);
new TestB(x2);
}
}
public 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("test.apicontainer.OneMoreApiClass", getSourceForOneMoreApiClass()),
new StaticJavaResource("java.newpackage.Test", getSourceForTest()),};
}
private static JAbstractMethod getMethodByName(String name, ApiClass apiClass) {
return (apiClass.getApiMethodsByName(name, ApiClass.MethodType.METHOD).toArray(
new ApiAbstractMethod[0])[0]).getMethod();
}
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 java.lang.Object checkParametersAndReturnTypes(ApiClass a) { return this; };\n");
sb.append("\tpublic final java.lang.Object checkParametersAndReturnTypesFinalVersion(ApiClass a) { return this; };\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(NonApiClass a) { };\n");
sb.append("\tpublic int fieldInNonApiClass = 3;\n");
sb.append("\tprotected class ApiClassInNonApiClass {\n");
sb.append("\tprotected ApiClassInNonApiClass() { }\n");
sb.append("\t}\n");
sb.append("\tprotected final class AnotherApiClassInNonApiClass {\n");
sb.append("\tprivate AnotherApiClassInNonApiClass() { }\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("\tprivate void internalMethod() { }\n");
sb.append("\tprotected native long protectedMethod();\n");
sb.append("\tprotected void checkOverloadedAndOverridableDetection(java.lang.Object b) { }\n");
sb.append("\tprotected final void checkOverloadedMethodAccounted(java.lang.Object b) { }\n");
sb.append("\tpublic int apiField = 0;\n");
sb.append("\tprotected transient int apiFieldWillBeMissing = 1;\n");
sb.append("\tprivate int internalField = 0;\n");
sb.append("\tprotected 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 final void checkOverloadedMethodAccounted(test.apicontainer.OneMoreApiClass b) { }\n");
sb.append("\tpublic void testUncheckedExceptions () { }\n");
sb.append("};\n");
return sb.toString();
}
private static String getSourceForTest() {
StringBuffer sb = new StringBuffer();
sb.append("package java.newpackage;\n");
sb.append("public class Test { }\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();
}
ApiContainer apiCheck = null;
AbstractTreeLogger logger = new PrintWriterTreeLogger();
/**
* Class hierarchy. public java.lang.Object -- test.apicontainer.NonApiClass
* (encloses ApiClassInNonApiClass and AnotherApiClassInNonApiClass) -- public
* test.apicontainer.ApiClass -- test.nonapipackage.TestClass
*/
@Override
public void setUp() throws UnableToCompleteException {
logger.setMaxDetail(com.google.gwt.core.ext.TreeLogger.ERROR);
apiCheck =
new ApiContainer("ApiContainerTest", new HashSet<Resource>(Arrays.asList(getScuArray())),
new HashSet<String>(), logger);
}
/*
* Test if ApiContainer correctly creates an ApiContainer (for example, avoids
* an infinite loop) when a nested class extends an outer class.
*/
public void testApiContainerLoop() throws UnableToCompleteException {
StringBuffer sb = new StringBuffer();
sb.append("package java.lang;\n");
sb.append("public class Object {\n");
sb.append("\tpublic static class Foo extends Object{\n");
sb.append("\t}\n");
sb.append("}\n");
sb.append("class Temp {\n");
sb.append("}");
ApiContainer apiCheckLoop =
new ApiContainer("ApiClassTest", new HashSet<Resource>(Arrays
.asList(new StaticJavaResource[] {new StaticJavaResource("java.lang.Object", sb
.toString())})), new HashSet<String>(), logger);
ApiPackage javaLangPackage = apiCheckLoop.getApiPackage("java.lang");
assertNotNull(javaLangPackage);
assertNotNull(javaLangPackage.getApiClass("java.lang.Object"));
assertEquals(2, javaLangPackage.getApiClassNames().size());
}
public void testEverything() {
checkApiClass();
checkApiMembers();
checkApiPackages();
}
/**
* Check if apiClasses are determined correctly. Check if inner classes are
* classified correctly as api classes.
*/
void checkApiClass() {
ApiPackage package1 = apiCheck.getApiPackage("java.lang");
ApiPackage package2 = apiCheck.getApiPackage("test.apicontainer");
assertNotNull(package1);
assertNotNull(package2);
assertNull(package2.getApiClass("test.apicontainer.NonApiClass"));
assertNotNull(package1.getApiClass("java.lang.Object"));
assertNotNull(package2.getApiClass("test.apicontainer.ApiClass"));
assertNotNull(package2.getApiClass("test.apicontainer.NonApiClass.ApiClassInNonApiClass"));
assertNotNull(package2
.getApiClass("test.apicontainer.NonApiClass.AnotherApiClassInNonApiClass"));
assertEquals(1, package1.getApiClassNames().size());
assertEquals(4, package2.getApiClassNames().size());
}
/**
* Since constructors and methods use the same code, check methods in most
* cases. Also need to check apiFields.
*
* For methods, check if: (a) inherited methods are identified correctly as
* apiMethods, (b) method overloading is done correctly
*
*/
void checkApiMembers() {
ApiClass object = apiCheck.getApiPackage("java.lang").getApiClass("java.lang.Object");
ApiClass apiClass =
apiCheck.getApiPackage("test.apicontainer").getApiClass("test.apicontainer.ApiClass");
ApiClass innerClass =
apiCheck.getApiPackage("test.apicontainer").getApiClass(
"test.apicontainer.NonApiClass.ApiClassInNonApiClass");
ApiClass oneMoreApiClass =
apiCheck.getApiPackage("test.apicontainer")
.getApiClass("test.apicontainer.OneMoreApiClass");
// constructors
assertEquals(1, innerClass.getApiMemberNames(ApiClass.MethodType.CONSTRUCTOR).size());
// fields
assertEquals(3, object.getApiFieldNames().size());
assertEquals(4, apiClass.getApiFieldNames().size());
assertEquals(3, oneMoreApiClass.getApiFieldNames().size());
// methods
assertEquals(4, object.getApiMemberNames(ApiClass.MethodType.METHOD).size());
assertEquals(7, apiClass.getApiMemberNames(ApiClass.MethodType.METHOD).size());
// the method definition lowest in the class hierarchy is kept
assertNotSame(getMethodByName("apiMethod0", apiClass), getMethodByName("apiMethod0", object));
assertEquals(getMethodByName("protectedMethod0", apiClass), getMethodByName("protectedMethod0",
object));
assertNotNull(getMethodByName("methodInNonApiClass1", apiClass));
assertEquals(5, oneMoreApiClass.getApiMemberNames(ApiClass.MethodType.METHOD).size());
Set<String> methodNames =
new HashSet<String>(Arrays.asList(new String[] {"checkOverloadedAndOverridableDetection1"}));
assertEquals(1, oneMoreApiClass.getApiMembersBySet(methodNames, ApiClass.MethodType.METHOD)
.size());
// checkOverloadedMethodAccounted should appear twice.
methodNames =
new HashSet<String>(Arrays.asList(new String[] {"checkOverloadedMethodAccounted1"}));
assertEquals(2, oneMoreApiClass.getApiMembersBySet(methodNames, ApiClass.MethodType.METHOD)
.size());
}
/**
* Test if apiPackages are identified correctly.
*/
void checkApiPackages() {
assertNotNull(apiCheck.getApiPackage("java.lang"));
assertNotNull(apiCheck.getApiPackage("test.apicontainer"));
assertEquals(3, apiCheck.getApiPackageNames().size());
}
}