| /** |
| * Copyright (C) 2007 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.inject.assistedinject; |
| |
| import com.google.inject.AbstractModule; |
| import static com.google.inject.Asserts.assertContains; |
| import com.google.inject.Binding; |
| import com.google.inject.ConfigurationException; |
| import com.google.inject.CreationException; |
| import com.google.inject.Guice; |
| import com.google.inject.Inject; |
| import com.google.inject.Injector; |
| import com.google.inject.Key; |
| import com.google.inject.Provider; |
| import com.google.inject.TypeLiteral; |
| import com.google.inject.internal.util.ImmutableSet; |
| import com.google.inject.name.Named; |
| import com.google.inject.name.Names; |
| import com.google.inject.spi.Dependency; |
| import com.google.inject.spi.HasDependencies; |
| import java.awt.Color; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Set; |
| import junit.framework.TestCase; |
| |
| /** |
| * @author jmourits@google.com (Jerome Mourits) |
| * @author jessewilson@google.com (Jesse Wilson) |
| */ |
| public class FactoryProviderTest extends TestCase { |
| |
| public void testAssistedFactory() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(Double.class).toInstance(5.0d); |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Mustang.class)); |
| } |
| }); |
| ColoredCarFactory carFactory = injector.getInstance(ColoredCarFactory.class); |
| |
| Mustang blueMustang = (Mustang) carFactory.create(Color.BLUE); |
| assertEquals(Color.BLUE, blueMustang.color); |
| assertEquals(5.0d, blueMustang.engineSize); |
| |
| Mustang redMustang = (Mustang) carFactory.create(Color.RED); |
| assertEquals(Color.RED, redMustang.color); |
| assertEquals(5.0d, redMustang.engineSize); |
| } |
| |
| public void testFactoryBindingDependencies() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(Double.class).toInstance(5.0d); |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Mustang.class)); |
| } |
| }); |
| |
| Binding<?> binding = injector.getBinding(ColoredCarFactory.class); |
| HasDependencies hasDependencies = (HasDependencies) binding; |
| assertEquals(ImmutableSet.<Dependency<?>>of(Dependency.get(Key.get(double.class))), |
| hasDependencies.getDependencies()); |
| } |
| |
| public void testAssistedFactoryWithAnnotations() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(int.class).annotatedWith(Names.named("horsePower")).toInstance(250); |
| bind(int.class).annotatedWith(Names.named("modelYear")).toInstance(1984); |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Camaro.class)); |
| } |
| }); |
| |
| ColoredCarFactory carFactory = injector.getInstance(ColoredCarFactory.class); |
| |
| Camaro blueCamaro = (Camaro) carFactory.create(Color.BLUE); |
| assertEquals(Color.BLUE, blueCamaro.color); |
| assertEquals(1984, blueCamaro.modelYear); |
| assertEquals(250, blueCamaro.horsePower); |
| |
| Camaro redCamaro = (Camaro) carFactory.create(Color.RED); |
| assertEquals(Color.RED, redCamaro.color); |
| assertEquals(1984, redCamaro.modelYear); |
| assertEquals(250, redCamaro.horsePower); |
| } |
| |
| interface Car { |
| } |
| |
| interface ColoredCarFactory { |
| Car create(Color color); |
| } |
| |
| public static class Mustang implements Car { |
| private final double engineSize; |
| private final Color color; |
| |
| @AssistedInject |
| public Mustang(double engineSize, @Assisted Color color) { |
| this.engineSize = engineSize; |
| this.color = color; |
| } |
| } |
| |
| public static class Camaro implements Car { |
| private final int horsePower; |
| private final int modelYear; |
| private final Color color; |
| |
| @AssistedInject |
| public Camaro( |
| @Named("horsePower")int horsePower, |
| @Named("modelYear")int modelYear, |
| @Assisted Color color) { |
| this.horsePower = horsePower; |
| this.modelYear = modelYear; |
| this.color = color; |
| } |
| } |
| |
| interface SummerCarFactory { |
| Car create(Color color, boolean convertable); |
| Car createConvertible(Color color); |
| } |
| |
| public void testFactoryWithMultipleMethods() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(float.class).toInstance(140f); |
| bind(SummerCarFactory.class).toProvider( |
| FactoryProvider.newFactory(SummerCarFactory.class, Corvette.class)); |
| } |
| }); |
| |
| SummerCarFactory carFactory = injector.getInstance(SummerCarFactory.class); |
| |
| Corvette blueCorvette = (Corvette) carFactory.createConvertible(Color.BLUE); |
| assertEquals(Color.BLUE, blueCorvette.color); |
| assertEquals(100f, blueCorvette.maxMph); |
| assertTrue(blueCorvette.isConvertable); |
| |
| Corvette redCorvette = (Corvette) carFactory.create(Color.RED, false); |
| assertEquals(Color.RED, redCorvette.color); |
| assertEquals(140f, redCorvette.maxMph); |
| assertFalse(redCorvette.isConvertable); |
| } |
| |
| public static class Corvette implements Car { |
| private boolean isConvertable; |
| private Color color; |
| private float maxMph; |
| |
| @AssistedInject |
| public Corvette(@Assisted Color color) { |
| this(color, 100f, true); |
| } |
| |
| public Corvette(@Assisted Color color, @Assisted boolean isConvertable) { |
| throw new IllegalStateException("Not an @AssistedInject constructor"); |
| } |
| |
| @AssistedInject |
| public Corvette(@Assisted Color color, Float maxMph, @Assisted boolean isConvertable) { |
| this.isConvertable = isConvertable; |
| this.color = color; |
| this.maxMph = maxMph; |
| } |
| } |
| |
| public void testFactoryMethodsMismatch() { |
| try { |
| FactoryProvider.newFactory(SummerCarFactory.class, Beetle.class); |
| fail(); |
| } catch(ConfigurationException e) { |
| assertContains(e.getMessage(), "Constructor mismatch"); |
| } |
| } |
| |
| public static class Beetle implements Car { |
| @AssistedInject |
| public Beetle(@Assisted Color color) { |
| throw new IllegalStateException("Conflicting constructors"); |
| } |
| @AssistedInject |
| public Beetle(@Assisted Color color, @Assisted boolean isConvertable) { |
| throw new IllegalStateException("Conflicting constructors"); |
| } |
| @AssistedInject |
| public Beetle(@Assisted Color color, @Assisted boolean isConvertable, float maxMph) { |
| throw new IllegalStateException("Conflicting constructors"); |
| } |
| } |
| |
| public void testMethodsAndFieldsGetInjected() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(String.class).toInstance("turbo"); |
| bind(int.class).toInstance(911); |
| bind(double.class).toInstance(50000d); |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Porshe.class)); |
| } |
| }); |
| ColoredCarFactory carFactory = injector.getInstance(ColoredCarFactory.class); |
| |
| Porshe grayPorshe = (Porshe) carFactory.create(Color.GRAY); |
| assertEquals(Color.GRAY, grayPorshe.color); |
| assertEquals(50000d, grayPorshe.price); |
| assertEquals(911, grayPorshe.model); |
| assertEquals("turbo", grayPorshe.name); |
| } |
| |
| public static class Porshe implements Car { |
| private final Color color; |
| private final double price; |
| private @Inject String name; |
| private int model; |
| |
| @AssistedInject |
| public Porshe(@Assisted Color color, double price) { |
| this.color = color; |
| this.price = price; |
| } |
| |
| @Inject void setModel(int model) { |
| this.model = model; |
| } |
| } |
| |
| public void testProviderInjection() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(String.class).toInstance("trans am"); |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Firebird.class)); |
| } |
| }); |
| ColoredCarFactory carFactory = injector.getInstance(ColoredCarFactory.class); |
| |
| Firebird blackFirebird = (Firebird) carFactory.create(Color.BLACK); |
| assertEquals(Color.BLACK, blackFirebird.color); |
| assertEquals("trans am", blackFirebird.modifiersProvider.get()); |
| } |
| |
| public static class Firebird implements Car { |
| private final Provider<String> modifiersProvider; |
| private final Color color; |
| |
| @AssistedInject |
| public Firebird(Provider<String> modifiersProvider, @Assisted Color color) { |
| this.modifiersProvider = modifiersProvider; |
| this.color = color; |
| } |
| } |
| |
| public void testTypeTokenInjection() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(new TypeLiteral<Set<String>>() {}).toInstance(Collections.singleton("Flux Capacitor")); |
| bind(new TypeLiteral<Set<Integer>>() {}).toInstance(Collections.singleton(88)); |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, DeLorean.class)); |
| } |
| }); |
| ColoredCarFactory carFactory = injector.getInstance(ColoredCarFactory.class); |
| |
| DeLorean deLorean = (DeLorean) carFactory.create(Color.GRAY); |
| assertEquals(Color.GRAY, deLorean.color); |
| assertEquals("Flux Capacitor", deLorean.features.iterator().next()); |
| assertEquals(new Integer(88), deLorean.featureActivationSpeeds.iterator().next()); |
| } |
| |
| public static class DeLorean implements Car { |
| private final Set<String> features; |
| private final Set<Integer> featureActivationSpeeds; |
| private final Color color; |
| |
| @AssistedInject |
| public DeLorean( |
| Set<String> extraFeatures, Set<Integer> featureActivationSpeeds, @Assisted Color color) { |
| this.features = extraFeatures; |
| this.featureActivationSpeeds = featureActivationSpeeds; |
| this.color = color; |
| } |
| } |
| |
| public void testTypeTokenProviderInjection() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(new TypeLiteral<Set<String>>() { }).toInstance(Collections.singleton("Datsun")); |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Z.class)); |
| } |
| }); |
| ColoredCarFactory carFactory = injector.getInstance(ColoredCarFactory.class); |
| |
| Z orangeZ = (Z) carFactory.create(Color.ORANGE); |
| assertEquals(Color.ORANGE, orangeZ.color); |
| assertEquals("Datsun", orangeZ.manufacturersProvider.get().iterator().next()); |
| } |
| |
| public static class Z implements Car { |
| private final Provider<Set<String>> manufacturersProvider; |
| private final Color color; |
| |
| @AssistedInject |
| public Z(Provider<Set<String>> manufacturersProvider, @Assisted Color color) { |
| this.manufacturersProvider = manufacturersProvider; |
| this.color = color; |
| } |
| } |
| |
| public static class Prius implements Car { |
| @SuppressWarnings("unused") |
| private final Color color; |
| |
| @AssistedInject |
| private Prius(@Assisted Color color) { |
| this.color = color; |
| } |
| } |
| |
| public void testAssistInjectionInNonPublicConstructor() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Prius.class)); |
| } |
| }); |
| Car car = injector.getInstance(ColoredCarFactory.class).create(Color.ORANGE); |
| } |
| |
| public static class ExplodingCar implements Car { |
| @AssistedInject |
| public ExplodingCar(@Assisted Color color) { |
| throw new IllegalStateException("kaboom!"); |
| } |
| } |
| |
| public void testExceptionDuringConstruction() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(ColoredCarFactory.class).toProvider( |
| FactoryProvider.newFactory(ColoredCarFactory.class, ExplodingCar.class)); |
| } |
| }); |
| try { |
| injector.getInstance(ColoredCarFactory.class).create(Color.ORANGE); |
| fail(); |
| } catch (IllegalStateException e) { |
| assertEquals("kaboom!", e.getMessage()); |
| } |
| } |
| |
| public static class DefectiveCar implements Car { |
| @AssistedInject |
| public DefectiveCar() throws ExplosionException, FireException { |
| throw new ExplosionException(); |
| } |
| } |
| |
| public static class ExplosionException extends Exception { } |
| public static class FireException extends Exception { } |
| |
| public interface DefectiveCarFactoryWithNoExceptions { |
| Car createCar(); |
| } |
| |
| public interface DefectiveCarFactory { |
| Car createCar() throws FireException; |
| } |
| |
| public void testFactoryMethodMustDeclareAllConstructorExceptions() { |
| try { |
| FactoryProvider.newFactory(DefectiveCarFactoryWithNoExceptions.class, DefectiveCar.class); |
| fail(); |
| } catch (ConfigurationException expected) { |
| assertContains(expected.getMessage(), "no compatible exception is thrown"); |
| } |
| } |
| |
| public interface CorrectDefectiveCarFactory { |
| Car createCar() throws FireException, ExplosionException; |
| } |
| |
| public void testConstructorExceptionsAreThrownByFactory() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(CorrectDefectiveCarFactory.class).toProvider( |
| FactoryProvider.newFactory( |
| CorrectDefectiveCarFactory.class, DefectiveCar.class)); |
| } |
| }); |
| try { |
| injector.getInstance(CorrectDefectiveCarFactory.class).createCar(); |
| fail(); |
| } catch (FireException e) { |
| fail(); |
| } catch (ExplosionException expected) { |
| } |
| } |
| |
| public static class MultipleConstructorDefectiveCar implements Car { |
| @AssistedInject |
| public MultipleConstructorDefectiveCar() throws ExplosionException { |
| throw new ExplosionException(); |
| } |
| |
| @AssistedInject |
| public MultipleConstructorDefectiveCar(@Assisted Color c) throws FireException { |
| throw new FireException(); |
| } |
| } |
| |
| public interface MultipleConstructorDefectiveCarFactory { |
| Car createCar() throws ExplosionException; |
| Car createCar(Color r) throws FireException; |
| } |
| |
| public void testMultipleConstructorExceptionMatching() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(MultipleConstructorDefectiveCarFactory.class).toProvider( |
| FactoryProvider.newFactory( |
| MultipleConstructorDefectiveCarFactory.class, |
| MultipleConstructorDefectiveCar.class)); |
| } |
| }); |
| MultipleConstructorDefectiveCarFactory factory |
| = injector.getInstance(MultipleConstructorDefectiveCarFactory.class); |
| try { |
| factory.createCar(); |
| fail(); |
| } catch (ExplosionException expected) { |
| } |
| |
| try { |
| factory.createCar(Color.RED); |
| fail(); |
| } catch (FireException expected) { |
| } |
| } |
| |
| public static class WildcardCollection { |
| |
| public interface Factory { |
| WildcardCollection create(Collection<?> items); |
| } |
| |
| @AssistedInject |
| public WildcardCollection(@Assisted Collection<?> items) { } |
| } |
| |
| public void testWildcardGenerics() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(WildcardCollection.Factory.class).toProvider( |
| FactoryProvider.newFactory( |
| WildcardCollection.Factory.class, |
| WildcardCollection.class)); |
| } |
| }); |
| WildcardCollection.Factory factory = injector.getInstance(WildcardCollection.Factory.class); |
| factory.create(Collections.emptyList()); |
| } |
| |
| public static class SteeringWheel {} |
| |
| public static class Fiat implements Car { |
| @SuppressWarnings("unused") |
| private final SteeringWheel steeringWheel; |
| @SuppressWarnings("unused") |
| private final Color color; |
| |
| @AssistedInject |
| public Fiat(SteeringWheel steeringWheel, @Assisted Color color) { |
| this.steeringWheel = steeringWheel; |
| this.color = color; |
| } |
| } |
| |
| public void testFactoryWithImplicitBindings() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(ColoredCarFactory.class).toProvider( |
| FactoryProvider.newFactory( |
| ColoredCarFactory.class, |
| Fiat.class)); |
| } |
| }); |
| |
| ColoredCarFactory coloredCarFactory = injector.getInstance(ColoredCarFactory.class); |
| Fiat fiat = (Fiat) coloredCarFactory.create(Color.GREEN); |
| assertEquals(Color.GREEN, fiat.color); |
| assertNotNull(fiat.steeringWheel); |
| } |
| |
| public void testFactoryFailsWithMissingBinding() { |
| try { |
| Guice.createInjector(new AbstractModule() { |
| @Override protected void configure() { |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Mustang.class)); |
| } |
| }); |
| fail(); |
| } catch (CreationException expected) { |
| assertContains(expected.getMessage(), |
| "1) Parameter of type 'double' is not injectable or annotated with @Assisted"); |
| } |
| } |
| |
| public void testMethodsDeclaredInObject() { |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override protected void configure() { |
| bind(Double.class).toInstance(5.0d); |
| bind(ColoredCarFactory.class) |
| .toProvider(FactoryProvider.newFactory(ColoredCarFactory.class, Mustang.class)); |
| } |
| }); |
| |
| ColoredCarFactory carFactory = injector.getInstance(ColoredCarFactory.class); |
| |
| carFactory.equals(carFactory); |
| carFactory.hashCode(); |
| carFactory.toString(); |
| } |
| |
| public void testAssistedInjectConstructorAndAssistedFactoryParameterMustNotMix() { |
| try { |
| Guice.createInjector(new AbstractModule() { |
| @Override protected void configure() { |
| bind(Double.class).toInstance(5.0d); |
| bind(AssistedParamsFactory.class) |
| .toProvider(FactoryProvider.newFactory(AssistedParamsFactory.class, Mustang.class)); |
| } |
| }); |
| fail(); |
| } catch (CreationException expected) { |
| assertContains(expected.getMessage(), "Factory method " |
| + AssistedParamsFactory.class.getName() + ".create() has an @Assisted parameter, which " |
| + "is incompatible with the deprecated @AssistedInject annotation."); |
| } |
| } |
| |
| interface AssistedParamsFactory { |
| Car create(@Assisted Color color); |
| } |
| |
| interface GenericColoredCarFactory<T extends Car> { |
| T create(Color color); |
| } |
| |
| public void testGenericAssistedFactory() { |
| final TypeLiteral<GenericColoredCarFactory<Mustang>> mustangTypeLiteral |
| = new TypeLiteral<GenericColoredCarFactory<Mustang>>() {}; |
| final TypeLiteral<GenericColoredCarFactory<Camaro>> camaroTypeLiteral |
| = new TypeLiteral<GenericColoredCarFactory<Camaro>>() {}; |
| |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(Double.class).toInstance(5.0d); |
| bind(int.class).annotatedWith(Names.named("horsePower")).toInstance(250); |
| bind(int.class).annotatedWith(Names.named("modelYear")).toInstance(1984); |
| bind(mustangTypeLiteral).toProvider( |
| FactoryProvider.newFactory(mustangTypeLiteral, TypeLiteral.get(Mustang.class))); |
| bind(camaroTypeLiteral).toProvider( |
| FactoryProvider.newFactory(camaroTypeLiteral, TypeLiteral.get(Camaro.class))); |
| } |
| }); |
| |
| GenericColoredCarFactory<Mustang> mustangFactory |
| = injector.getInstance(Key.get(mustangTypeLiteral)); |
| GenericColoredCarFactory<Camaro> camaroFactory |
| = injector.getInstance(Key.get(camaroTypeLiteral)); |
| |
| Mustang blueMustang = mustangFactory.create(Color.BLUE); |
| assertEquals(Color.BLUE, blueMustang.color); |
| assertEquals(5.0d, blueMustang.engineSize); |
| |
| Camaro redCamaro = camaroFactory.create(Color.RED); |
| assertEquals(Color.RED, redCamaro.color); |
| assertEquals(1984, redCamaro.modelYear); |
| assertEquals(250, redCamaro.horsePower); |
| } |
| |
| public interface Insurance<T extends Car> { |
| } |
| |
| public static class MustangInsurance implements Insurance<Mustang> { |
| private final double premium; |
| private final double limit; |
| private Mustang car; |
| |
| @AssistedInject |
| public MustangInsurance(@Named("lowLimit") double limit, @Assisted Mustang car, |
| @Assisted double premium) { |
| this.premium = premium; |
| this.limit = limit; |
| this.car = car; |
| } |
| |
| public void sell() {} |
| } |
| |
| public static class CamaroInsurance implements Insurance<Camaro> { |
| private final double premium; |
| private final double limit; |
| private Camaro car; |
| |
| @AssistedInject |
| public CamaroInsurance(@Named("highLimit") double limit, @Assisted Camaro car, |
| @Assisted double premium) { |
| this.premium = premium; |
| this.limit = limit; |
| this.car = car; |
| } |
| |
| public void sell() {} |
| } |
| |
| public interface MustangInsuranceFactory { |
| public Insurance<Mustang> create(Mustang car, double premium); |
| } |
| |
| public interface CamaroInsuranceFactory { |
| public Insurance<Camaro> create(Camaro car, double premium); |
| } |
| |
| public void testAssistedFactoryForConcreteType() { |
| |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(Double.class).annotatedWith(Names.named("lowLimit")).toInstance(50000.0d); |
| bind(Double.class).annotatedWith(Names.named("highLimit")).toInstance(100000.0d); |
| bind(MustangInsuranceFactory.class).toProvider( |
| FactoryProvider.newFactory(MustangInsuranceFactory.class, MustangInsurance.class)); |
| bind(CamaroInsuranceFactory.class).toProvider( |
| FactoryProvider.newFactory(CamaroInsuranceFactory.class, CamaroInsurance.class)); |
| } |
| }); |
| |
| MustangInsuranceFactory mustangInsuranceFactory = |
| injector.getInstance(MustangInsuranceFactory.class); |
| CamaroInsuranceFactory camaroInsuranceFactory = |
| injector.getInstance(CamaroInsuranceFactory.class); |
| |
| Mustang mustang = new Mustang(5000d, Color.BLACK); |
| MustangInsurance mustangPolicy = |
| (MustangInsurance) mustangInsuranceFactory.create(mustang, 800.0d); |
| assertEquals(800.0d, mustangPolicy.premium); |
| assertEquals(50000.0d, mustangPolicy.limit); |
| |
| Camaro camaro = new Camaro(3000, 1967, Color.BLUE); |
| CamaroInsurance camaroPolicy = (CamaroInsurance) camaroInsuranceFactory.create(camaro, 800.0d); |
| assertEquals(800.0d, camaroPolicy.premium); |
| assertEquals(100000.0d, camaroPolicy.limit); |
| } |
| |
| public interface InsuranceFactory<T extends Car> { |
| public Insurance<T> create(T car, double premium); |
| } |
| |
| public void testAssistedFactoryForParameterizedType() { |
| final TypeLiteral<InsuranceFactory<Mustang>> mustangInsuranceFactoryType = |
| new TypeLiteral<InsuranceFactory<Mustang>>() {}; |
| final TypeLiteral<InsuranceFactory<Camaro>> camaroInsuranceFactoryType = |
| new TypeLiteral<InsuranceFactory<Camaro>>() {}; |
| |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(Double.class).annotatedWith(Names.named("lowLimit")).toInstance(50000.0d); |
| bind(Double.class).annotatedWith(Names.named("highLimit")).toInstance(100000.0d); |
| bind(mustangInsuranceFactoryType).toProvider(FactoryProvider.newFactory( |
| mustangInsuranceFactoryType, TypeLiteral.get(MustangInsurance.class))); |
| bind(camaroInsuranceFactoryType).toProvider(FactoryProvider.newFactory( |
| camaroInsuranceFactoryType, TypeLiteral.get(CamaroInsurance.class))); |
| } |
| }); |
| |
| InsuranceFactory<Mustang> mustangInsuranceFactory = |
| injector.getInstance(Key.get(mustangInsuranceFactoryType)); |
| InsuranceFactory<Camaro> camaroInsuranceFactory = |
| injector.getInstance(Key.get(camaroInsuranceFactoryType)); |
| |
| Mustang mustang = new Mustang(5000d, Color.BLACK); |
| MustangInsurance mustangPolicy = |
| (MustangInsurance) mustangInsuranceFactory.create(mustang, 800.0d); |
| assertEquals(800.0d, mustangPolicy.premium); |
| assertEquals(50000.0d, mustangPolicy.limit); |
| |
| Camaro camaro = new Camaro(3000, 1967, Color.BLUE); |
| CamaroInsurance camaroPolicy = (CamaroInsurance) camaroInsuranceFactory.create(camaro, 800.0d); |
| assertEquals(800.0d, camaroPolicy.premium); |
| assertEquals(100000.0d, camaroPolicy.limit); |
| } |
| |
| public static class AutoInsurance<T extends Car> implements Insurance<T> { |
| private final double premium; |
| private final double limit; |
| private final T car; |
| |
| @AssistedInject |
| public AutoInsurance(double limit, @Assisted T car, @Assisted double premium) { |
| this.limit = limit; |
| this.car = car; |
| this.premium = premium; |
| } |
| |
| public void sell() {} |
| } |
| |
| public void testAssistedFactoryForTypeVariableParameters() { |
| final TypeLiteral<InsuranceFactory<Camaro>> camaroInsuranceFactoryType = |
| new TypeLiteral<InsuranceFactory<Camaro>>() {}; |
| |
| Injector injector = Guice.createInjector(new AbstractModule() { |
| @Override |
| protected void configure() { |
| bind(Double.class).toInstance(50000.0d); |
| bind(camaroInsuranceFactoryType).toProvider(FactoryProvider.newFactory( |
| camaroInsuranceFactoryType, new TypeLiteral<AutoInsurance<Camaro>>() {})); |
| } |
| }); |
| |
| InsuranceFactory<Camaro> camaroInsuranceFactory = |
| injector.getInstance(Key.get(camaroInsuranceFactoryType)); |
| |
| Camaro camaro = new Camaro(3000, 1967, Color.BLUE); |
| AutoInsurance camaroPolicy = (AutoInsurance) camaroInsuranceFactory.create(camaro, 800.0d); |
| assertEquals(800.0d, camaroPolicy.premium); |
| assertEquals(50000.0d, camaroPolicy.limit); |
| assertEquals(camaro, camaroPolicy.car); |
| } |
| } |
