/*
* Copyright 2013 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.gwt.client;
import com.google.gwt.core.client.GWT;
import com.google.gwt.junit.client.GWTTestCase;
import com.google.web.bindery.event.shared.SimpleEventBus;
import com.google.web.bindery.requestfactory.shared.ProxyFor;
import com.google.web.bindery.requestfactory.shared.Receiver;
import com.google.web.bindery.requestfactory.shared.Request;
import com.google.web.bindery.requestfactory.shared.RequestContext;
import com.google.web.bindery.requestfactory.shared.RequestFactory;
import com.google.web.bindery.requestfactory.shared.Service;
import com.google.web.bindery.requestfactory.shared.SkipInterfaceValidation;
import com.google.web.bindery.requestfactory.shared.ValueProxy;
import java.util.Collections;
import java.util.List;
/**
* Tests usage of generics in RequestFactory.
*/
@SkipInterfaceValidation
public class RequestFactoryGenericsTest extends GWTTestCase {
/** Service under test. */
public static class Impl {
public static Domain echoDomain(Domain domainObject) {
return domainObject;
}
public static BaseDomain<?, ?> getBase() {
return new BaseDomain<Integer, Float>() {
{
setListOfStrings(Collections.singletonList("foo"));
}
@Override
public void setA(Integer a) {
throw new UnsupportedOperationException();
}
@Override
public Integer getA() {
throw new UnsupportedOperationException();
}
@Override
public List<Integer> getListOfA() {
throw new UnsupportedOperationException();
}
@Override
public void setListOfA(List<Integer> list) {
throw new UnsupportedOperationException();
}
};
}
public static Container echoContainer(Container container) {
return container;
}
}
/** Generic interface implemented by both proxy and domain object. */
public interface HasA<A> {
A getA();
void setA(A a);
List<A> getListOfA();
void setListOfA(List<A> list);
}
/** Base generic domain object. */
public static abstract class BaseDomain<A, B> implements HasA<A> {
private B b;
private List<String> listOfStrings;
public B getB() {
return b;
}
public void setB(B b) {
this.b = b;
}
public List<String> getListOfStrings() {
return this.listOfStrings;
}
public void setListOfStrings(List<String> list) {
this.listOfStrings = list;
}
}
/** Domain object that "locks" generic type params from base class. */
public static class Domain extends BaseDomain<String, Boolean> {
private String str;
private List<String> list;
@Override
public String getA() {
return str;
}
@Override
public void setA(String a) {
str = a;
}
@Override
public List<String> getListOfA() {
return list;
}
@Override
public void setListOfA(List<String> list) {
this.list = list;
}
}
/** Domain object containing another object with inherited generics. */
public static class Container {
private Domain domain;
public Domain getDomain() {
return domain;
}
public void setDomain(Domain domain) {
this.domain = domain;
}
}
/** Proxy testing that the domain type can be parameterized. */
@ProxyFor(BaseDomain.class)
public interface BaseDomainProxy extends ValueProxy {
List<String> getListOfStrings();
void setListOfStrings(List<String> listOfStrings);
}
/** Proxy implementing generic interface (locking the type param). */
@ProxyFor(Domain.class)
public interface DomainProxy extends BaseDomainProxy, HasA<String> {
Boolean getB();
void setB(Boolean b);
}
/** Base interface references proxy "with generics". */
public interface BaseContainerProxy {
BaseDomainProxy getDomain();
}
/**
* Child-interface overrides method with co-variant return type (with
* "locked" type params).
*/
@ProxyFor(Container.class)
public interface ContainerProxy extends ValueProxy, BaseContainerProxy {
@Override
DomainProxy getDomain();
void setDomain(DomainProxy domain);
}
/** Request context under test. */
@Service(Impl.class)
public interface Context extends RequestContext {
Request<DomainProxy> echoDomain(DomainProxy proxy);
Request<BaseDomainProxy> getBase();
Request<ContainerProxy> echoContainer(ContainerProxy container);
}
/** Factory under test. */
public interface Factory extends RequestFactory {
Context ctx();
}
@Override
public String getModuleName() {
return "com.google.web.bindery.requestfactory.gwt.RequestFactorySuite";
}
private static final int TEST_DELAY = 5000;
protected Factory factory;
public void testEchoDomain() throws Exception {
delayTestFinish(TEST_DELAY);
Context ctx = factory.ctx();
DomainProxy proxy = ctx.create(DomainProxy.class);
proxy.setA("foo");
proxy.setB(true);
proxy.setListOfA(Collections.singletonList("bar"));
proxy.setListOfStrings(Collections.singletonList("baz"));
ctx.echoDomain(proxy).fire(new Receiver<DomainProxy>() {
@Override
public void onSuccess(DomainProxy response) {
assertEquals("foo", response.getA());
assertEquals(Boolean.TRUE, response.getB());
assertEquals(Collections.singletonList("bar"), response.getListOfA());
assertEquals(Collections.singletonList("baz"), response.getListOfStrings());
finishTest();
}
});
}
public void testGetBase() throws Exception {
delayTestFinish(TEST_DELAY);
Context ctx = factory.ctx();
ctx.getBase().fire(new Receiver<BaseDomainProxy>() {
@Override
public void onSuccess(BaseDomainProxy response) {
assertEquals(Collections.singletonList("foo"), response.getListOfStrings());
finishTest();
}
});
}
public void testEchoContainer() throws Exception {
delayTestFinish(TEST_DELAY);
Context ctx = factory.ctx();
DomainProxy proxy = ctx.create(DomainProxy.class);
proxy.setA("42");
ContainerProxy container = ctx.create(ContainerProxy.class);
container.setDomain(proxy);
ctx.echoContainer(container).fire(new Receiver<ContainerProxy>() {
@Override
public void onSuccess(ContainerProxy response) {
assertEquals("42", response.getDomain().getA());
finishTest();
}
});
}
@Override
protected void gwtSetUp() throws Exception {
factory = createFactory();
}
protected Factory createFactory() {
Factory factory = GWT.create(Factory.class);
factory.initialize(new SimpleEventBus());
return factory;
}
}