diff options
Diffstat (limited to 'tck/org/atinject/tck/auto/Convertible.java')
| -rw-r--r-- | tck/org/atinject/tck/auto/Convertible.java | 573 |
1 files changed, 573 insertions, 0 deletions
diff --git a/tck/org/atinject/tck/auto/Convertible.java b/tck/org/atinject/tck/auto/Convertible.java new file mode 100644 index 0000000..b5b7c48 --- /dev/null +++ b/tck/org/atinject/tck/auto/Convertible.java @@ -0,0 +1,573 @@ +/* + * Copyright (C) 2009 The JSR-330 Expert Group + * + * 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 org.atinject.tck.auto; + +import junit.framework.TestCase; +import org.atinject.tck.auto.accessories.Cupholder; +import org.atinject.tck.auto.accessories.SpareTire; +import org.atinject.tck.auto.accessories.RoundThing; + +import javax.inject.Inject; +import javax.inject.Named; +import javax.inject.Provider; + +public class Convertible implements Car { + + @Inject @Drivers Seat driversSeatA; + @Inject @Drivers Seat driversSeatB; + @Inject SpareTire spareTire; + @Inject Cupholder cupholder; + @Inject Provider<Engine> engineProvider; + + private boolean methodWithZeroParamsInjected; + private boolean methodWithMultipleParamsInjected; + private boolean methodWithNonVoidReturnInjected; + + private Seat constructorPlainSeat; + private Seat constructorDriversSeat; + private Tire constructorPlainTire; + private Tire constructorSpareTire; + private Provider<Seat> constructorPlainSeatProvider = nullProvider(); + private Provider<Seat> constructorDriversSeatProvider = nullProvider(); + private Provider<Tire> constructorPlainTireProvider = nullProvider(); + private Provider<Tire> constructorSpareTireProvider = nullProvider(); + + @Inject Seat fieldPlainSeat; + @Inject @Drivers Seat fieldDriversSeat; + @Inject Tire fieldPlainTire; + @Inject @Named("spare") Tire fieldSpareTire; + @Inject Provider<Seat> fieldPlainSeatProvider = nullProvider(); + @Inject @Drivers Provider<Seat> fieldDriversSeatProvider = nullProvider(); + @Inject Provider<Tire> fieldPlainTireProvider = nullProvider(); + @Inject @Named("spare") Provider<Tire> fieldSpareTireProvider = nullProvider(); + + private Seat methodPlainSeat; + private Seat methodDriversSeat; + private Tire methodPlainTire; + private Tire methodSpareTire; + private Provider<Seat> methodPlainSeatProvider = nullProvider(); + private Provider<Seat> methodDriversSeatProvider = nullProvider(); + private Provider<Tire> methodPlainTireProvider = nullProvider(); + private Provider<Tire> methodSpareTireProvider = nullProvider(); + + @Inject static Seat staticFieldPlainSeat; + @Inject @Drivers static Seat staticFieldDriversSeat; + @Inject static Tire staticFieldPlainTire; + @Inject @Named("spare") static Tire staticFieldSpareTire; + @Inject static Provider<Seat> staticFieldPlainSeatProvider = nullProvider(); + @Inject @Drivers static Provider<Seat> staticFieldDriversSeatProvider = nullProvider(); + @Inject static Provider<Tire> staticFieldPlainTireProvider = nullProvider(); + @Inject @Named("spare") static Provider<Tire> staticFieldSpareTireProvider = nullProvider(); + + private static Seat staticMethodPlainSeat; + private static Seat staticMethodDriversSeat; + private static Tire staticMethodPlainTire; + private static Tire staticMethodSpareTire; + private static Provider<Seat> staticMethodPlainSeatProvider = nullProvider(); + private static Provider<Seat> staticMethodDriversSeatProvider = nullProvider(); + private static Provider<Tire> staticMethodPlainTireProvider = nullProvider(); + private static Provider<Tire> staticMethodSpareTireProvider = nullProvider(); + + @Inject Convertible( + Seat plainSeat, + @Drivers Seat driversSeat, + Tire plainTire, + @Named("spare") Tire spareTire, + Provider<Seat> plainSeatProvider, + @Drivers Provider<Seat> driversSeatProvider, + Provider<Tire> plainTireProvider, + @Named("spare") Provider<Tire> spareTireProvider) { + constructorPlainSeat = plainSeat; + constructorDriversSeat = driversSeat; + constructorPlainTire = plainTire; + constructorSpareTire = spareTire; + constructorPlainSeatProvider = plainSeatProvider; + constructorDriversSeatProvider = driversSeatProvider; + constructorPlainTireProvider = plainTireProvider; + constructorSpareTireProvider = spareTireProvider; + } + + Convertible() { + throw new AssertionError("Unexpected call to non-injectable constructor"); + } + + void setSeat(Seat unused) { + throw new AssertionError("Unexpected call to non-injectable method"); + } + + @Inject void injectMethodWithZeroArgs() { + methodWithZeroParamsInjected = true; + } + + @Inject String injectMethodWithNonVoidReturn() { + methodWithNonVoidReturnInjected = true; + return "unused"; + } + + @Inject void injectInstanceMethodWithManyArgs( + Seat plainSeat, + @Drivers Seat driversSeat, + Tire plainTire, + @Named("spare") Tire spareTire, + Provider<Seat> plainSeatProvider, + @Drivers Provider<Seat> driversSeatProvider, + Provider<Tire> plainTireProvider, + @Named("spare") Provider<Tire> spareTireProvider) { + methodWithMultipleParamsInjected = true; + + methodPlainSeat = plainSeat; + methodDriversSeat = driversSeat; + methodPlainTire = plainTire; + methodSpareTire = spareTire; + methodPlainSeatProvider = plainSeatProvider; + methodDriversSeatProvider = driversSeatProvider; + methodPlainTireProvider = plainTireProvider; + methodSpareTireProvider = spareTireProvider; + } + + @Inject static void injectStaticMethodWithManyArgs( + Seat plainSeat, + @Drivers Seat driversSeat, + Tire plainTire, + @Named("spare") Tire spareTire, + Provider<Seat> plainSeatProvider, + @Drivers Provider<Seat> driversSeatProvider, + Provider<Tire> plainTireProvider, + @Named("spare") Provider<Tire> spareTireProvider) { + staticMethodPlainSeat = plainSeat; + staticMethodDriversSeat = driversSeat; + staticMethodPlainTire = plainTire; + staticMethodSpareTire = spareTire; + staticMethodPlainSeatProvider = plainSeatProvider; + staticMethodDriversSeatProvider = driversSeatProvider; + staticMethodPlainTireProvider = plainTireProvider; + staticMethodSpareTireProvider = spareTireProvider; + } + + /** + * Returns a provider that always returns null. This is used as a default + * value to avoid null checks for omitted provider injections. + */ + private static <T> Provider<T> nullProvider() { + return new Provider<T>() { + public T get() { + return null; + } + }; + } + + public static ThreadLocal<Convertible> localConvertible + = new ThreadLocal<Convertible>(); + + public static class Tests extends TestCase { + + private final Convertible car = localConvertible.get(); + private final Cupholder cupholder = car.cupholder; + private final SpareTire spareTire = car.spareTire; + private final Tire plainTire = car.fieldPlainTire; + private final Engine engine = car.engineProvider.get(); + + // smoke tests: if these fail all bets are off + + public void testFieldsInjected() { + assertTrue(cupholder != null && spareTire != null); + } + + public void testProviderReturnedValues() { + assertTrue(engine != null); + } + + // injecting different kinds of members + + public void testMethodWithZeroParametersInjected() { + assertTrue(car.methodWithZeroParamsInjected); + } + + public void testMethodWithMultipleParametersInjected() { + assertTrue(car.methodWithMultipleParamsInjected); + } + + public void testNonVoidMethodInjected() { + assertTrue(car.methodWithNonVoidReturnInjected); + } + + public void testPublicNoArgsConstructorInjected() { + assertTrue(engine.publicNoArgsConstructorInjected); + } + + public void testSubtypeFieldsInjected() { + assertTrue(spareTire.hasSpareTireBeenFieldInjected()); + } + + public void testSubtypeMethodsInjected() { + assertTrue(spareTire.hasSpareTireBeenMethodInjected()); + } + + public void testSupertypeFieldsInjected() { + assertTrue(spareTire.hasTireBeenFieldInjected()); + } + + public void testSupertypeMethodsInjected() { + assertTrue(spareTire.hasTireBeenMethodInjected()); + } + + public void testTwiceOverriddenMethodInjectedWhenMiddleLacksAnnotation() { + assertTrue(engine.overriddenTwiceWithOmissionInMiddleInjected); + } + + // injected values + + public void testQualifiersNotInheritedFromOverriddenMethod() { + assertFalse(engine.qualifiersInheritedFromOverriddenMethod); + } + + public void testConstructorInjectionWithValues() { + assertFalse("Expected unqualified value", + car.constructorPlainSeat instanceof DriversSeat); + assertFalse("Expected unqualified value", + car.constructorPlainTire instanceof SpareTire); + assertTrue("Expected qualified value", + car.constructorDriversSeat instanceof DriversSeat); + assertTrue("Expected qualified value", + car.constructorSpareTire instanceof SpareTire); + } + + public void testFieldInjectionWithValues() { + assertFalse("Expected unqualified value", + car.fieldPlainSeat instanceof DriversSeat); + assertFalse("Expected unqualified value", + car.fieldPlainTire instanceof SpareTire); + assertTrue("Expected qualified value", + car.fieldDriversSeat instanceof DriversSeat); + assertTrue("Expected qualified value", + car.fieldSpareTire instanceof SpareTire); + } + + public void testMethodInjectionWithValues() { + assertFalse("Expected unqualified value", + car.methodPlainSeat instanceof DriversSeat); + assertFalse("Expected unqualified value", + car.methodPlainTire instanceof SpareTire); + assertTrue("Expected qualified value", + car.methodDriversSeat instanceof DriversSeat); + assertTrue("Expected qualified value", + car.methodSpareTire instanceof SpareTire); + } + + // injected providers + + public void testConstructorInjectionWithProviders() { + assertFalse("Expected unqualified value", + car.constructorPlainSeatProvider.get() instanceof DriversSeat); + assertFalse("Expected unqualified value", + car.constructorPlainTireProvider.get() instanceof SpareTire); + assertTrue("Expected qualified value", + car.constructorDriversSeatProvider.get() instanceof DriversSeat); + assertTrue("Expected qualified value", + car.constructorSpareTireProvider.get() instanceof SpareTire); + } + + public void testFieldInjectionWithProviders() { + assertFalse("Expected unqualified value", + car.fieldPlainSeatProvider.get() instanceof DriversSeat); + assertFalse("Expected unqualified value", + car.fieldPlainTireProvider.get() instanceof SpareTire); + assertTrue("Expected qualified value", + car.fieldDriversSeatProvider.get() instanceof DriversSeat); + assertTrue("Expected qualified value", + car.fieldSpareTireProvider.get() instanceof SpareTire); + } + + public void testMethodInjectionWithProviders() { + assertFalse("Expected unqualified value", + car.methodPlainSeatProvider.get() instanceof DriversSeat); + assertFalse("Expected unqualified value", + car.methodPlainTireProvider.get() instanceof SpareTire); + assertTrue("Expected qualified value", + car.methodDriversSeatProvider.get() instanceof DriversSeat); + assertTrue("Expected qualified value", + car.methodSpareTireProvider.get() instanceof SpareTire); + } + + + // singletons + + public void testConstructorInjectedProviderYieldsSingleton() { + assertSame("Expected same value", + car.constructorPlainSeatProvider.get(), car.constructorPlainSeatProvider.get()); + } + + public void testFieldInjectedProviderYieldsSingleton() { + assertSame("Expected same value", + car.fieldPlainSeatProvider.get(), car.fieldPlainSeatProvider.get()); + } + + public void testMethodInjectedProviderYieldsSingleton() { + assertSame("Expected same value", + car.methodPlainSeatProvider.get(), car.methodPlainSeatProvider.get()); + } + + public void testCircularlyDependentSingletons() { + // uses provider.get() to get around circular deps + assertSame(cupholder.seatProvider.get().getCupholder(), cupholder); + } + + + // non singletons + + public void testSingletonAnnotationNotInheritedFromSupertype() { + assertNotSame(car.driversSeatA, car.driversSeatB); + } + + public void testConstructorInjectedProviderYieldsDistinctValues() { + assertNotSame("Expected distinct values", + car.constructorDriversSeatProvider.get(), car.constructorDriversSeatProvider.get()); + assertNotSame("Expected distinct values", + car.constructorPlainTireProvider.get(), car.constructorPlainTireProvider.get()); + assertNotSame("Expected distinct values", + car.constructorSpareTireProvider.get(), car.constructorSpareTireProvider.get()); + } + + public void testFieldInjectedProviderYieldsDistinctValues() { + assertNotSame("Expected distinct values", + car.fieldDriversSeatProvider.get(), car.fieldDriversSeatProvider.get()); + assertNotSame("Expected distinct values", + car.fieldPlainTireProvider.get(), car.fieldPlainTireProvider.get()); + assertNotSame("Expected distinct values", + car.fieldSpareTireProvider.get(), car.fieldSpareTireProvider.get()); + } + + public void testMethodInjectedProviderYieldsDistinctValues() { + assertNotSame("Expected distinct values", + car.methodDriversSeatProvider.get(), car.methodDriversSeatProvider.get()); + assertNotSame("Expected distinct values", + car.methodPlainTireProvider.get(), car.methodPlainTireProvider.get()); + assertNotSame("Expected distinct values", + car.methodSpareTireProvider.get(), car.methodSpareTireProvider.get()); + } + + + // mix inheritance + visibility + + public void testPackagePrivateMethodInjectedDifferentPackages() { + assertTrue(spareTire.subPackagePrivateMethodInjected); + assertTrue(spareTire.superPackagePrivateMethodInjected); + } + + public void testOverriddenProtectedMethodInjection() { + assertTrue(spareTire.subProtectedMethodInjected); + assertFalse(spareTire.superProtectedMethodInjected); + } + + public void testOverriddenPublicMethodNotInjected() { + assertTrue(spareTire.subPublicMethodInjected); + assertFalse(spareTire.superPublicMethodInjected); + } + + + // inject in order + + public void testFieldsInjectedBeforeMethods() { + assertFalse(spareTire.methodInjectedBeforeFields); + } + + public void testSupertypeMethodsInjectedBeforeSubtypeFields() { + assertFalse(spareTire.subtypeFieldInjectedBeforeSupertypeMethods); + } + + public void testSupertypeMethodInjectedBeforeSubtypeMethods() { + assertFalse(spareTire.subtypeMethodInjectedBeforeSupertypeMethods); + } + + + // necessary injections occur + + public void testPackagePrivateMethodInjectedEvenWhenSimilarMethodLacksAnnotation() { + assertTrue(spareTire.subPackagePrivateMethodForOverrideInjected); + } + + + // override or similar method without @Inject + + public void testPrivateMethodNotInjectedWhenSupertypeHasAnnotatedSimilarMethod() { + assertFalse(spareTire.superPrivateMethodForOverrideInjected); + } + + public void testPackagePrivateMethodNotInjectedWhenOverrideLacksAnnotation() { + assertFalse(engine.subPackagePrivateMethodForOverrideInjected); + assertFalse(engine.superPackagePrivateMethodForOverrideInjected); + } + + public void testPackagePrivateMethodNotInjectedWhenSupertypeHasAnnotatedSimilarMethod() { + assertFalse(spareTire.superPackagePrivateMethodForOverrideInjected); + } + + public void testProtectedMethodNotInjectedWhenOverrideNotAnnotated() { + assertFalse(spareTire.protectedMethodForOverrideInjected); + } + + public void testPublicMethodNotInjectedWhenOverrideNotAnnotated() { + assertFalse(spareTire.publicMethodForOverrideInjected); + } + + public void testTwiceOverriddenMethodNotInjectedWhenOverrideLacksAnnotation() { + assertFalse(engine.overriddenTwiceWithOmissionInSubclassInjected); + } + + public void testOverriddingMixedWithPackagePrivate2() { + assertTrue(spareTire.packagePrivateMethod2Injected); + assertTrue(((Tire) spareTire).packagePrivateMethod2Injected); + assertFalse(((RoundThing) spareTire).packagePrivateMethod2Injected); + + assertTrue(plainTire.packagePrivateMethod2Injected); + assertTrue(((RoundThing) plainTire).packagePrivateMethod2Injected); + } + + public void testOverriddingMixedWithPackagePrivate3() { + assertFalse(spareTire.packagePrivateMethod3Injected); + assertTrue(((Tire) spareTire).packagePrivateMethod3Injected); + assertFalse(((RoundThing) spareTire).packagePrivateMethod3Injected); + + assertTrue(plainTire.packagePrivateMethod3Injected); + assertTrue(((RoundThing) plainTire).packagePrivateMethod3Injected); + } + + public void testOverriddingMixedWithPackagePrivate4() { + assertFalse(plainTire.packagePrivateMethod4Injected); + assertTrue(((RoundThing) plainTire).packagePrivateMethod4Injected); + } + + // inject only once + + public void testOverriddenPackagePrivateMethodInjectedOnlyOnce() { + assertFalse(engine.overriddenPackagePrivateMethodInjectedTwice); + } + + public void testSimilarPackagePrivateMethodInjectedOnlyOnce() { + assertFalse(spareTire.similarPackagePrivateMethodInjectedTwice); + } + + public void testOverriddenProtectedMethodInjectedOnlyOnce() { + assertFalse(spareTire.overriddenProtectedMethodInjectedTwice); + } + + public void testOverriddenPublicMethodInjectedOnlyOnce() { + assertFalse(spareTire.overriddenPublicMethodInjectedTwice); + } + + } + + public static class StaticTests extends TestCase { + + public void testSubtypeStaticFieldsInjected() { + assertTrue(SpareTire.hasBeenStaticFieldInjected()); + } + + public void testSubtypeStaticMethodsInjected() { + assertTrue(SpareTire.hasBeenStaticMethodInjected()); + } + + public void testSupertypeStaticFieldsInjected() { + assertTrue(Tire.hasBeenStaticFieldInjected()); + } + + public void testSupertypeStaticMethodsInjected() { + assertTrue(Tire.hasBeenStaticMethodInjected()); + } + + public void testStaticFieldInjectionWithValues() { + assertFalse("Expected unqualified value", + staticFieldPlainSeat instanceof DriversSeat); + assertFalse("Expected unqualified value", + staticFieldPlainTire instanceof SpareTire); + assertTrue("Expected qualified value", + staticFieldDriversSeat instanceof DriversSeat); + assertTrue("Expected qualified value", + staticFieldSpareTire instanceof SpareTire); + } + + public void testStaticMethodInjectionWithValues() { + assertFalse("Expected unqualified value", + staticMethodPlainSeat instanceof DriversSeat); + assertFalse("Expected unqualified value", + staticMethodPlainTire instanceof SpareTire); + assertTrue("Expected qualified value", + staticMethodDriversSeat instanceof DriversSeat); + assertTrue("Expected qualified value", + staticMethodSpareTire instanceof SpareTire); + } + + public void testStaticFieldsInjectedBeforeMethods() { + assertFalse(SpareTire.staticMethodInjectedBeforeStaticFields); + } + + public void testSupertypeStaticMethodsInjectedBeforeSubtypeStaticFields() { + assertFalse(SpareTire.subtypeStaticFieldInjectedBeforeSupertypeStaticMethods); + } + + public void testSupertypeStaticMethodsInjectedBeforeSubtypeStaticMethods() { + assertFalse(SpareTire.subtypeStaticMethodInjectedBeforeSupertypeStaticMethods); + } + + public void testStaticFieldInjectionWithProviders() { + assertFalse("Expected unqualified value", + staticFieldPlainSeatProvider.get() instanceof DriversSeat); + assertFalse("Expected unqualified value", + staticFieldPlainTireProvider.get() instanceof SpareTire); + assertTrue("Expected qualified value", + staticFieldDriversSeatProvider.get() instanceof DriversSeat); + assertTrue("Expected qualified value", + staticFieldSpareTireProvider.get() instanceof SpareTire); + } + + public void testStaticMethodInjectionWithProviders() { + assertFalse("Expected unqualified value", + staticMethodPlainSeatProvider.get() instanceof DriversSeat); + assertFalse("Expected unqualified value", + staticMethodPlainTireProvider.get() instanceof SpareTire); + assertTrue("Expected qualified value", + staticMethodDriversSeatProvider.get() instanceof DriversSeat); + assertTrue("Expected qualified value", + staticMethodSpareTireProvider.get() instanceof SpareTire); + } + } + + public static class PrivateTests extends TestCase { + + private final Convertible car = localConvertible.get(); + private final Engine engine = car.engineProvider.get(); + private final SpareTire spareTire = car.spareTire; + + public void testSupertypePrivateMethodInjected() { + assertTrue(spareTire.superPrivateMethodInjected); + assertTrue(spareTire.subPrivateMethodInjected); + } + + public void testPackagePrivateMethodInjectedSamePackage() { + assertTrue(engine.subPackagePrivateMethodInjected); + assertFalse(engine.superPackagePrivateMethodInjected); + } + + public void testPrivateMethodInjectedEvenWhenSimilarMethodLacksAnnotation() { + assertTrue(spareTire.subPrivateMethodForOverrideInjected); + } + + public void testSimilarPrivateMethodInjectedOnlyOnce() { + assertFalse(spareTire.similarPrivateMethodInjectedTwice); + } + } +} |