/*
* Copyright 2011 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.web.bindery.requestfactory.apt;
import com.google.gwt.dev.util.Util;
import com.google.web.bindery.requestfactory.gwt.client.RequestFactoryPolymorphicTest;
import com.google.web.bindery.requestfactory.shared.LoggingRequest;
import com.google.web.bindery.requestfactory.shared.SimpleRequestFactory;
import com.google.web.bindery.requestfactory.shared.TestRequestFactory;
import com.google.web.bindery.requestfactory.shared.impl.FindRequest;
import junit.framework.TestCase;
import java.io.File;
import java.io.IOException;
import java.io.StringWriter;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.TreeSet;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileObject;
import javax.tools.SimpleJavaFileObject;
import javax.tools.ToolProvider;
/**
* Integration test of {@link RfValidator} using the Java6 tools API to invoke
* the Java compiler. This test requires that the gwt-user source is available
* on the classpath.
*/
public class RfValidatorTest extends TestCase {
/**
* Provides access to a source file from the classpath.
*/
private static class UriJavaFileObject extends SimpleJavaFileObject {
public static UriJavaFileObject create(Class<?> toLoad) {
try {
String path = toLoad.getName().replace('.', '/') + ".java";
/*
* SimpleJavaFileObject does not like the URI's created from jar URLs
* since their path does not start with a leading forward-slash. The
* choice of "classpath" as the scheme is arbitrary and meaningless.
*/
URI fakeLocation = new URI("classpath:/" + path);
return new UriJavaFileObject(fakeLocation, Thread.currentThread().getContextClassLoader()
.getResource(path));
} catch (URISyntaxException e) {
throw new RuntimeException(e);
}
}
private final URL contents;
public UriJavaFileObject(URI fakeLocation, URL contents) throws URISyntaxException {
super(fakeLocation, JavaFileObject.Kind.SOURCE);
this.contents = contents;
}
@Override
public CharSequence getCharContent(boolean ignored) throws IOException {
return Util.readStreamAsString(contents.openStream());
}
}
/**
* Smoke test to ensure that appropriate errors and warnings are emitted.
*/
public void testErrorsAndWarnings() throws IOException {
testGeneratedMessages(EntityProxyCheckDomainMapping.class);
testGeneratedMessages(EntityProxyMismatchedFind.class);
testGeneratedMessages(EntityProxyMissingDomainLocatorMethods.class);
testGeneratedMessages(EntityProxyMissingDomainType.class);
testGeneratedMessages(MyRequestContext.class);
testGeneratedMessages(MyRequestFactory.class);
testGeneratedMessages(RequestContextMissingDomainType.class);
testGeneratedMessages(RequestContextUsingUnmappedProxy.class,
EntityProxyMissingDomainType.class);
testGeneratedMessages(RequestContextWithMismatchedBoxes.class);
testGeneratedMessages(RequestContextWithMismatchedInstance.class);
}
/**
* The target classes for this method don't contain any {@code @Expect}
* annotations, so this test will verify that they are error- and
* warning-free.
*/
public void testTestClasses() throws IOException {
testGeneratedMessages(RequestFactoryPolymorphicTest.class);
testGeneratedMessages(FindRequest.class);
testGeneratedMessages(LoggingRequest.class);
testGeneratedMessages(SimpleRequestFactory.class);
testGeneratedMessages(TestRequestFactory.class);
}
/**
* The target classes for this method don't contain any {@code @Expect}
* annotations, so this test will verify that they are error- and
* warning-free.
*
* @throws IOException
*/
public void testTestClassesClientOnly() throws IOException {
testGeneratedMessages(true, RequestFactoryPolymorphicTest.class);
testGeneratedMessages(true, FindRequest.class);
testGeneratedMessages(true, LoggingRequest.class);
testGeneratedMessages(true, SimpleRequestFactory.class);
testGeneratedMessages(true, TestRequestFactory.class);
}
private void assertEquals(TreeSet<Diagnostic<? extends JavaFileObject>> expected,
TreeSet<Diagnostic<? extends JavaFileObject>> actual) {
List<Diagnostic<?>> unmatched = new ArrayList<Diagnostic<?>>();
// Remove actual elements from expect, saving any unexpected elements
for (Diagnostic<? extends JavaFileObject> d : actual) {
if (!expected.remove(d)) {
unmatched.add(d);
}
}
assertTrue("Did not see expected errors: " + expected + "\n\nLeftovers :" + unmatched, expected
.isEmpty());
assertTrue("Unexpected errors: " + unmatched, unmatched.isEmpty());
}
private void testGeneratedMessages(Class<?>... classes) throws IOException {
testGeneratedMessages(false, classes);
}
/**
* Run the annotation processor over one or more classes and verify that the
* appropriate messages are generated.
*/
private void testGeneratedMessages(boolean clientOnly, Class<?>... classes) throws IOException {
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
if (compiler == null) {
// This test is being run without a full JDK
return;
}
// Don't spray files in random locations
File tempFile = File.createTempFile(RfValidatorTest.class.getSimpleName(), ".jar");
tempFile.deleteOnExit();
JavaFileManager fileManager =
new ValidationTool.JarOrDirectoryOutputFileManager(tempFile, compiler
.getStandardFileManager(null, null, null));
List<JavaFileObject> files = new ArrayList<JavaFileObject>(classes.length);
for (Class<?> clazz : classes) {
JavaFileObject obj = UriJavaFileObject.create(clazz);
files.add(obj);
}
StringWriter errorWriter = new StringWriter();
RfValidator rfValidator = new RfValidator();
rfValidator.setForceErrors(true);
rfValidator.setClientOnly(clientOnly);
DiagnosticCollector<JavaFileObject> expectedCollector =
new DiagnosticCollector<JavaFileObject>();
CompilationTask expectedTask =
compiler.getTask(errorWriter, fileManager, expectedCollector, Arrays.asList("-proc:only"),
null, files);
expectedTask.setProcessors(Arrays.asList(new ExpectCollector()));
expectedTask.call();
DiagnosticCollector<JavaFileObject> actualCollector = new DiagnosticCollector<JavaFileObject>();
CompilationTask actualTask =
compiler.getTask(errorWriter, fileManager, actualCollector, Arrays.asList("-proc:only"),
null, files);
actualTask.setProcessors(Arrays.asList(rfValidator));
actualTask.call();
TreeSet<Diagnostic<? extends JavaFileObject>> expected =
new TreeSet<Diagnostic<? extends JavaFileObject>>(new DiagnosticComparator());
expected.addAll(expectedCollector.getDiagnostics());
TreeSet<Diagnostic<? extends JavaFileObject>> actual =
new TreeSet<Diagnostic<? extends JavaFileObject>>(new DiagnosticComparator());
actual.addAll(actualCollector.getDiagnostics());
assertEquals(expected, actual);
}
}