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