| /* |
| * 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.junit.rebind; |
| |
| import com.google.gwt.core.client.JavaScriptObject; |
| import com.google.gwt.core.ext.BadPropertyValueException; |
| import com.google.gwt.core.ext.ConfigurationProperty; |
| import com.google.gwt.core.ext.Generator; |
| import com.google.gwt.core.ext.GeneratorContext; |
| import com.google.gwt.core.ext.TreeLogger; |
| import com.google.gwt.core.ext.UnableToCompleteException; |
| import com.google.gwt.core.ext.typeinfo.JAbstractMethod; |
| import com.google.gwt.core.ext.typeinfo.JClassType; |
| import com.google.gwt.core.ext.typeinfo.JMethod; |
| import com.google.gwt.core.ext.typeinfo.JType; |
| import com.google.gwt.core.ext.typeinfo.NotFoundException; |
| import com.google.gwt.core.ext.typeinfo.TypeOracle; |
| import com.google.gwt.dev.util.collect.HashMap; |
| import com.google.gwt.junit.client.GWTTestCase; |
| import com.google.gwt.junit.client.GWTTestCase.TestModuleInfo; |
| import com.google.gwt.junit.client.impl.JUnitHost.TestInfo; |
| import com.google.gwt.junit.client.impl.MissingTestPlaceHolder; |
| import com.google.gwt.user.rebind.ClassSourceFileComposerFactory; |
| import com.google.gwt.user.rebind.SourceWriter; |
| |
| import java.io.PrintWriter; |
| import java.util.LinkedHashMap; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * A generator that generates {@code GWTTestMetadata}. |
| */ |
| public class GWTTestMetadataGenerator extends Generator { |
| |
| private static final String BASE_CLASS = "com.google.gwt.junit.client.impl.GWTTestMetadata"; |
| private static final JType[] NO_PARAMS = new JType[0]; |
| |
| private static String getPackagePrefix(JClassType classType) { |
| String name = classType.getPackage().getName(); |
| return (name.length() == 0) ? name : (name + '.'); |
| } |
| |
| /** |
| * Create a new type that satisfies the rebind request. |
| */ |
| @Override |
| public String generate(TreeLogger logger, GeneratorContext context, String typeName) |
| throws UnableToCompleteException { |
| if (!BASE_CLASS.equals(typeName)) { |
| logger.log(TreeLogger.ERROR, "This generator may only be used with " + BASE_CLASS, null); |
| throw new UnableToCompleteException(); |
| } |
| JClassType requestedClass; |
| try { |
| requestedClass = context.getTypeOracle().getType(typeName); |
| } catch (NotFoundException e) { |
| logger.log( |
| TreeLogger.ERROR, |
| "Could not find type '" |
| + typeName |
| + "'; please see the log, as this usually indicates a previous error ", |
| e); |
| throw new UnableToCompleteException(); |
| } |
| |
| String moduleName; |
| try { |
| ConfigurationProperty prop = context.getPropertyOracle().getConfigurationProperty( |
| "junit.moduleName"); |
| moduleName = prop.getValues().get(0); |
| } catch (BadPropertyValueException e) { |
| logger.log(TreeLogger.ERROR, |
| "Could not resolve junit.moduleName property", e); |
| throw new UnableToCompleteException(); |
| } |
| |
| String packageName = requestedClass.getPackage().getName(); |
| String generatedClass = requestedClass.getName() + "Impl"; |
| |
| SourceWriter sourceWriter = getSourceWriter(logger, context, packageName, generatedClass); |
| if (sourceWriter != null) { |
| writeCreateMethod(sourceWriter, getTestClasses(logger, context, moduleName)); |
| sourceWriter.commit(logger); |
| } |
| return packageName + "." + generatedClass; |
| } |
| |
| /** |
| * Will generate following: |
| * <pre> |
| * public native final JavaScriptObject get() /*-{ |
| * return { |
| * 'a.b.c.X' = { |
| * 'new' : function(test) { |
| * return @a.b.c.X::new(); |
| * }, |
| * 'testMethod1' = function(test) { |
| * return test.@a.b.c.X::testMethod1(); |
| * }, |
| * 'testMethod2' = function(test) { |
| * return test.@a.b.c.X::testMethod1(); |
| * }, |
| * }, |
| * |
| * 'k.l.m.Y' = { |
| * ... |
| * }, |
| * |
| * ... |
| * }; |
| * }-{@literal*}/; |
| * </pre> |
| */ |
| private void writeCreateMethod(SourceWriter sw, Map<String, JClassType> testClasses) { |
| sw.println("public native final %s get() /*-{", JavaScriptObject.class.getCanonicalName()); |
| sw.indent(); |
| sw.println("return {"); |
| for (Map.Entry<String, JClassType> entry : testClasses.entrySet()) { |
| sw.println("'%s': {", entry.getKey()); |
| writeFunctionMap(sw, entry.getValue()); |
| sw.println("},"); |
| } |
| sw.println("};"); |
| sw.outdent(); |
| sw.println("}-*/;"); |
| } |
| |
| private void writeFunctionMap(SourceWriter sw, JClassType jClassType) { |
| writeFunction(sw, jClassType.findConstructor(NO_PARAMS), true); |
| for (JMethod method : getTestMethods(jClassType)) { |
| writeFunction(sw, method, false); |
| } |
| } |
| |
| private void writeFunction(SourceWriter sw, JAbstractMethod method, boolean isConstructor) { |
| // Static method are also valid test methods |
| String object = (isConstructor || method.isMethod().isStatic()) ? "" : "test."; |
| String call = object + method.getJsniSignature(); |
| String methodName = isConstructor ? "new" : method.getName(); |
| sw.println("'%s' : function(test) { return %s(); },", methodName, call); |
| } |
| |
| private Map<String, JClassType> getTestClasses( |
| TreeLogger logger, GeneratorContext context, String moduleName) |
| throws UnableToCompleteException { |
| // Check the global set of active tests for this module. |
| TestModuleInfo moduleInfo = GWTTestCase.getTestsForModule(moduleName); |
| Set<TestInfo> moduleTests = (moduleInfo == null) ? null : moduleInfo.getTests(); |
| if (moduleTests == null || moduleTests.isEmpty()) { |
| logger.log(TreeLogger.ERROR, "No active tests found in module: " + moduleName); |
| throw new UnableToCompleteException(); |
| } |
| Map<String, JClassType> testClasses = new LinkedHashMap<String, JClassType>(); |
| for (TestInfo testInfo : moduleTests) { |
| String testClassName = testInfo.getTestClass(); |
| testClasses.put(testClassName, getTestClass(context.getTypeOracle(), testClassName)); |
| } |
| return testClasses; |
| } |
| |
| /** |
| * Returns the test class. If the class is not found in {@link TypeOracle}, then a place holder is |
| * returned in order to continue code generation. |
| * <p> |
| * If we don't continue code generation, we usually can't see the real cause of the compilation |
| * error in the logs. This also provides the benefit of continuing testing with the rest of test |
| * classes that still compiles. |
| */ |
| private JClassType getTestClass(TypeOracle typeOracle, String testClassName) { |
| JClassType type = typeOracle.findType(testClassName); |
| return type != null ? type |
| : typeOracle.findType(MissingTestPlaceHolder.class.getCanonicalName()); |
| } |
| |
| private SourceWriter getSourceWriter( |
| TreeLogger logger, GeneratorContext ctx, String packageName, String className) { |
| PrintWriter printWriter = ctx.tryCreate(logger, packageName, className); |
| if (printWriter == null) { |
| return null; |
| } |
| |
| ClassSourceFileComposerFactory composerFactory = |
| new ClassSourceFileComposerFactory(packageName, className); |
| composerFactory.setSuperclass(BASE_CLASS); |
| return composerFactory.createSourceWriter(ctx, printWriter); |
| } |
| |
| // This is compatible with how junit3 identifies test methods |
| private static Iterable<JMethod> getTestMethods(JClassType requestedClass) { |
| Map<String, JMethod> methodMap = new HashMap<String, JMethod>(); |
| for (JClassType cls = requestedClass; cls != null; cls = cls.getSuperclass()) { |
| for (JMethod declMethod : cls.getMethods()) { |
| if (isJUnitTestMethod(declMethod)) { |
| putIfAbsent(methodMap, declMethod); |
| } |
| } |
| } |
| return methodMap.values(); |
| } |
| |
| private static void putIfAbsent(Map<String, JMethod> methodMap, JMethod declMethod) { |
| if (!methodMap.containsKey(declMethod.getName())) { |
| methodMap.put(declMethod.getName(), declMethod); |
| } |
| } |
| |
| private static boolean isJUnitTestMethod(JMethod m) { |
| return m.isPublic() && m.getName().startsWith("test") && m.getParameters().length == 0 |
| && m.getReturnType().getQualifiedBinaryName().equals(Void.TYPE.getName()); |
| } |
| } |