user/src/com/google/gwt/junit/rebind/GWTTestMetadataGenerator.java

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