diff options
-rw-r--r-- | tck/org/atinject/tck/Tester.java | 55 | ||||
-rw-r--r-- | tck/org/atinject/tck/auto/Car.java | 6 | ||||
-rw-r--r-- | tck/org/atinject/tck/auto/Convertible.java | 450 | ||||
-rw-r--r-- | tck/org/atinject/tck/auto/Engine.java | 23 | ||||
-rw-r--r-- | tck/org/atinject/tck/auto/Seat.java | 2 | ||||
-rw-r--r-- | tck/org/atinject/tck/auto/Tire.java | 31 | ||||
-rw-r--r-- | tck/org/atinject/tck/auto/V8Engine.java | 25 | ||||
-rw-r--r-- | tck/org/atinject/tck/auto/accessories/Cupholder.java | 17 | ||||
-rw-r--r-- | tck/org/atinject/tck/auto/accessories/SpareTire.java | 57 |
9 files changed, 405 insertions, 261 deletions
diff --git a/tck/org/atinject/tck/Tester.java b/tck/org/atinject/tck/Tester.java deleted file mode 100644 index c989c22..0000000 --- a/tck/org/atinject/tck/Tester.java +++ /dev/null @@ -1,55 +0,0 @@ -/* - * 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; - -import java.util.List; -import java.util.ArrayList; -import java.util.Collection; - -public class Tester { - private final List<String> problems = new ArrayList<String>(); - - /** - * @param problem a brief description of what went wrong. - */ - public void addProblem(String problem) { - problems.add(problem); - } - - /** - * Adds a problem if {@code condition} is not true. - * - * @param problem a brief description of what went wrong. - */ - public void test(boolean condition, String problem) { - if (!condition) { - problems.add(problem); - } - } - - public boolean hasProblems() { - return !problems.isEmpty(); - } - - public Iterable<String> problems() { - return problems; - } - - public void addProblems(Collection<String> problems) { - this.problems.addAll(problems); - } -} diff --git a/tck/org/atinject/tck/auto/Car.java b/tck/org/atinject/tck/auto/Car.java index 7441fc1..d312ee5 100644 --- a/tck/org/atinject/tck/auto/Car.java +++ b/tck/org/atinject/tck/auto/Car.java @@ -16,12 +16,6 @@ package org.atinject.tck.auto; -import org.atinject.tck.Tester; - public interface Car { - /** - * Validates that this object was injected correctly. - */ - void check(Tester tester); } diff --git a/tck/org/atinject/tck/auto/Convertible.java b/tck/org/atinject/tck/auto/Convertible.java index 06b8b1b..50c6b3c 100644 --- a/tck/org/atinject/tck/auto/Convertible.java +++ b/tck/org/atinject/tck/auto/Convertible.java @@ -16,17 +16,13 @@ package org.atinject.tck.auto; -import org.atinject.tck.Tester; -import org.atinject.tck.auto.accessories.SpareTire; -import org.atinject.tck.auto.accessories.Cupholder; - import junit.framework.TestCase; +import org.atinject.tck.auto.accessories.Cupholder; +import org.atinject.tck.auto.accessories.SpareTire; import javax.inject.Inject; import javax.inject.Named; import javax.inject.Provider; -import java.util.ArrayList; -import java.util.List; public class Convertible implements Car { @@ -40,8 +36,6 @@ public class Convertible implements Car { private boolean methodWithMultipleParamsInjected; private boolean methodWithNonVoidReturnInjected; - private List<String> moreProblems = new ArrayList<String>(); - private Seat constructorPlainSeat; private Seat constructorDriversSeat; private Tire constructorPlainTire; @@ -175,107 +169,377 @@ public class Convertible implements Car { }; } - public void check(Tester tester) { - tester.addProblems(moreProblems); + /** + * Tests against the Convertible instance. + */ + public static class Tests extends TestCase { - tester.test(methodWithZeroParamsInjected, "Zero-parmeter method not injected"); - tester.test(methodWithMultipleParamsInjected, "Multi-parameter method not injected"); - tester.test(methodWithNonVoidReturnInjected, "Non-void method not injected"); - tester.test(driversSeatA != driversSeatB, "@Singleton inherited from supertype"); + public static ThreadLocal<Convertible> localConvertible + = new ThreadLocal<Convertible>(); - testInjectedValues(tester); - testProviders(tester); + private final Convertible car = localConvertible.get(); + private final Cupholder cupholder = car.cupholder; + private final SpareTire spareTire = car.spareTire; + private final Engine engine = car.engineProvider.get(); - Engine engine = engineProvider.get(); - if (spareTire == null || cupholder == null || engineProvider == null) { - tester.addProblem("Fields not injected"); - } else { - spareTire.check(tester); - cupholder.check(tester); + // smoke tests: if these fail all bets are off - if (engine == null) { - tester.addProblem("Provider returned null"); - } else { - engine.check(tester); - } + public void testFieldsInjected() { + assertTrue(cupholder != null && spareTire != null); } - } - private void testInjectedValues(Tester tester) { - testExpectedValues(tester, "injected constructor", - constructorPlainSeat, constructorDriversSeat, constructorPlainTire, constructorSpareTire); - testExpectedValues(tester, "provider injected into a constructor", constructorPlainSeatProvider.get(), - constructorDriversSeatProvider.get(), constructorPlainTireProvider.get(), constructorSpareTireProvider.get()); - testExpectedValues(tester, "injected field", - fieldPlainSeat, fieldDriversSeat, fieldPlainTire, fieldSpareTire); - testExpectedValues(tester, "provider injected into a field", fieldPlainSeatProvider.get(), - fieldDriversSeatProvider.get(), fieldPlainTireProvider.get(), fieldSpareTireProvider.get()); - testExpectedValues(tester, "injected method", - methodPlainSeat, methodDriversSeat, methodPlainTire, methodSpareTire); - testExpectedValues(tester, "provider injected into a method", methodPlainSeatProvider.get(), - methodDriversSeatProvider.get(), methodPlainTireProvider.get(), methodSpareTireProvider.get()); - testExpectedValues(tester, "injected static field", - staticFieldPlainSeat, staticFieldDriversSeat, staticFieldPlainTire, staticFieldSpareTire); - testExpectedValues(tester, "provider injected into a static field", staticFieldPlainSeatProvider.get(), - staticFieldDriversSeatProvider.get(), staticFieldPlainTireProvider.get(), staticFieldSpareTireProvider.get()); - testExpectedValues(tester, "injected static method", - staticMethodPlainSeat, staticMethodDriversSeat, staticMethodPlainTire, staticMethodSpareTire); - testExpectedValues(tester, "provider injected into a static method", staticMethodPlainSeatProvider.get(), - staticMethodDriversSeatProvider.get(), staticMethodPlainTireProvider.get(), staticMethodSpareTireProvider.get()); - } + public void testProviderReturnedValues() { + assertTrue(engine != null); + } - private void testProviders(Tester tester) { - testProviderProvidesNewValuesEachTime(tester, - constructorDriversSeatProvider, constructorPlainTireProvider, constructorSpareTireProvider); - testProviderProvidesNewValuesEachTime(tester, - fieldDriversSeatProvider, fieldPlainTireProvider, fieldSpareTireProvider); - testProviderProvidesNewValuesEachTime(tester, - methodDriversSeatProvider, methodPlainTireProvider, methodSpareTireProvider); - testProviderProvidesSameValueEachTime(tester, constructorPlainSeatProvider); - testProviderProvidesSameValueEachTime(tester, fieldPlainSeatProvider); - testProviderProvidesSameValueEachTime(tester, methodPlainSeatProvider); - } - private void testProviderProvidesSameValueEachTime(Tester tester, Provider<Seat> provider) { - tester.test(provider.get() == provider.get(), - "Different instance returned by repeated calls to Provider.get()"); - } + // injecting different kinds of members - private void testExpectedValues(Tester tester, String injectionMechanism, - Seat plainSeat, Seat driversSeat, Tire plainTire, Tire spareTire) { - tester.test(!(plainSeat instanceof DriversSeat), - "Wrong value injected for " + injectionMechanism); - tester.test(driversSeat instanceof DriversSeat, - "Wrong value injected for qualified " + injectionMechanism); - tester.test(!(plainTire instanceof SpareTire), - "Wrong value injected for " + injectionMechanism); - tester.test(spareTire instanceof SpareTire, - "Wrong value injected for @Named " + injectionMechanism); - } + public void testMethodWithZeroParametersInjected() { + assertTrue(car.methodWithZeroParamsInjected); + } - private void testProviderProvidesNewValuesEachTime(Tester tester, Provider<?>... providers) { - for (Provider provider : providers) { - tester.test(provider.get() != provider.get(), - "Same instance returned by repeated calls to Provider.get()"); + public void testMethodWithMultipleParametersInjected() { + assertTrue(car.methodWithMultipleParamsInjected); } - } - /** - * Tests against the Convertible instance. - */ - public static class Tests extends TestCase { + public void testNonVoidMethodInjected() { + assertTrue(car.methodWithNonVoidReturnInjected); + } - public static ThreadLocal<Convertible> localConvertible - = new ThreadLocal<Convertible>(); + 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 testSubtypeStaticFieldsInjected() { + assertTrue(SpareTire.hasBeenStaticFieldInjected()); + } + + public void testSubtypeStaticMethodsInjected() { + assertTrue(SpareTire.hasBeenStaticMethodInjected()); + } + + public void testSupertypeStaticFieldsInjected() { + assertTrue(Tire.hasBeenStaticFieldInjected()); + } + + public void testSupertypeStaticMethodsInjected() { + assertTrue(Tire.hasBeenStaticMethodInjected()); + } + + 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); + } + + 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); + } + + + // 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); + } + + 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); + } + + + // singletons - private final Car car = localConvertible.get(); + 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 testSupertypePrivateMethodInjected() { + assertTrue(spareTire.superPrivateMethodInjected); + assertTrue(spareTire.subPrivateMethodInjected); + } + + public void testPackagePrivateMethodInjectedSamePackage() { + assertTrue(engine.subPackagePrivateMethodInjected); + assertFalse(engine.superPackagePrivateMethodInjected); + } + + 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 testStaticFieldsInjectedBeforeMethods() { + assertFalse(SpareTire.staticMethodInjectedBeforeStaticFields); + } + + public void testSupertypeFieldsInjectedBeforeSubtypeMethods() { + assertFalse(spareTire.subtypeFieldInjectedBeforeSupertypeMethods); + } - public void testAll() { - Tester tester = new Tester(); - car.check(tester); - assertFalse(tester.problems().toString(), - tester.problems().iterator().hasNext()); + public void testSupertypeMethodsInjectedBeforeSubtypeMethods() { + assertFalse(spareTire.subtypeMethodInjectedBeforeSupertypeMethods); } + + public void testSupertypeStaticMethodsInjectedBeforeSubtypeStaticFields() { + assertFalse(SpareTire.subtypeStaticFieldInjectedBeforeSupertypeStaticMethods); + } + + public void testSupertypeStaticMethodsInjectedBeforeSubtypeStaticMethods() { + assertFalse(SpareTire.subtypeStaticMethodInjectedBeforeSupertypeStaticMethods); + } + + + // necessary injections occur + + public void testPrivateMethodInjectedEvenWhenSimilarMethodLacksAnnotation() { + assertTrue(spareTire.subPrivateMethodForOverrideInjected); + } + + 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); + } + + + // inject only once + + public void testOverriddenPackagePrivateMethodInjectedOnlyOnce() { + assertFalse(engine.overriddenPackagePrivateMethodInjectedTwice); + } + + public void testSimilarPrivateMethodInjectedOnlyOnce() { + assertFalse(spareTire.similarPrivateMethodInjectedTwice); + } + + public void testSimilarPackagePrivateMethodInjectedOnlyOnce() { + assertFalse(spareTire.similarPackagePrivateMethodInjectedTwice); + } + + public void testOverriddenProtectedMethodInjectedOnlyOnce() { + assertFalse(spareTire.overriddenProtectedMethodInjectedTwice); + } + + public void testOverriddenPublicMethodInjectedOnlyOnce() { + assertFalse(spareTire.overriddenPublicMethodInjectedTwice); + } + } } diff --git a/tck/org/atinject/tck/auto/Engine.java b/tck/org/atinject/tck/auto/Engine.java index 64ce6fe..e4231e5 100644 --- a/tck/org/atinject/tck/auto/Engine.java +++ b/tck/org/atinject/tck/auto/Engine.java @@ -17,20 +17,17 @@ package org.atinject.tck.auto; import org.atinject.tck.auto.accessories.SpareTire; -import org.atinject.tck.Tester; import javax.inject.Inject; import javax.inject.Named; -import java.util.List; -import java.util.ArrayList; public abstract class Engine { - protected final List<String> moreProblems = new ArrayList<String>(); - protected boolean publicNoArgsConstructorInjected; - protected boolean packagePrivateMethodInjected; - protected boolean packagePrivateMethodForOverrideInjected; + protected boolean subPackagePrivateMethodInjected; + protected boolean superPackagePrivateMethodInjected; + protected boolean subPackagePrivateMethodForOverrideInjected; + protected boolean superPackagePrivateMethodForOverrideInjected; protected boolean overriddenTwiceWithOmissionInMiddleInjected; protected boolean overriddenTwiceWithOmissionInSubclassInjected; @@ -40,12 +37,15 @@ public abstract class Engine { protected Tire tireA; protected Tire tireB; + public boolean overriddenPackagePrivateMethodInjectedTwice; + public boolean qualifiersInheritedFromOverriddenMethod; + @Inject void injectPackagePrivateMethod() { - moreProblems.add("Unexpected call to supertype package private method"); + superPackagePrivateMethodInjected = true; } @Inject void injectPackagePrivateMethodForOverride() { - moreProblems.add("Unexpected call to supertype package private method"); + superPackagePrivateMethodForOverrideInjected = true; } @Inject public void injectQualifiers(@Drivers Seat seatA, Seat seatB, @@ -54,7 +54,7 @@ public abstract class Engine { || (seatB instanceof DriversSeat) || !(tireA instanceof SpareTire) || (tireB instanceof SpareTire)) { - moreProblems.add("Qualifiers inherited from overridden methods"); + qualifiersInheritedFromOverriddenMethod = true; } } @@ -65,7 +65,4 @@ public abstract class Engine { @Inject public void injectTwiceOverriddenWithOmissionInSubclass() { overriddenTwiceWithOmissionInSubclassInjected = true; } - - public abstract void check(Tester tester); - } diff --git a/tck/org/atinject/tck/auto/Seat.java b/tck/org/atinject/tck/auto/Seat.java index 26fa5fe..4d41a20 100644 --- a/tck/org/atinject/tck/auto/Seat.java +++ b/tck/org/atinject/tck/auto/Seat.java @@ -18,8 +18,8 @@ package org.atinject.tck.auto; import org.atinject.tck.auto.accessories.Cupholder; -import javax.inject.Singleton; import javax.inject.Inject; +import javax.inject.Singleton; @Singleton public class Seat { diff --git a/tck/org/atinject/tck/auto/Tire.java b/tck/org/atinject/tck/auto/Tire.java index 2110e82..9d4f665 100644 --- a/tck/org/atinject/tck/auto/Tire.java +++ b/tck/org/atinject/tck/auto/Tire.java @@ -52,60 +52,71 @@ public class Tire { protected boolean protectedMethodForOverrideInjected; protected boolean publicMethodForOverrideInjected; + public boolean methodInjectedBeforeFields; + public boolean subtypeFieldInjectedBeforeSupertypeMethods; + public boolean subtypeMethodInjectedBeforeSupertypeMethods; + public static boolean staticMethodInjectedBeforeStaticFields; + public static boolean subtypeStaticFieldInjectedBeforeSupertypeStaticMethods; + public static boolean subtypeStaticMethodInjectedBeforeSupertypeStaticMethods; + public boolean similarPrivateMethodInjectedTwice; + public boolean similarPackagePrivateMethodInjectedTwice; + public boolean overriddenProtectedMethodInjectedTwice; + public boolean overriddenPublicMethodInjectedTwice; + @Inject public Tire(FuelTank constructorInjection) { this.constructorInjection = constructorInjection; } @Inject void supertypeMethodInjection(FuelTank methodInjection) { if (!hasTireBeenFieldInjected()) { - moreProblems.add("Method injected before fields"); + methodInjectedBeforeFields = true; } if (hasSpareTireBeenFieldInjected()) { - moreProblems.add("Subtype field injected before supertype method"); + subtypeFieldInjectedBeforeSupertypeMethods = true; } if (hasSpareTireBeenMethodInjected()) { - moreProblems.add("Subtype method injected before supertype method"); + subtypeMethodInjectedBeforeSupertypeMethods = true; } this.methodInjection = methodInjection; } @Inject static void supertypeStaticMethodInjection(FuelTank methodInjection) { if (!Tire.hasBeenStaticFieldInjected()) { - moreProblems.add("Static method injected before static fields"); + staticMethodInjectedBeforeStaticFields = true; } if (SpareTire.hasBeenStaticFieldInjected()) { - moreProblems.add("Subtype static field injected before supertype static method"); + subtypeStaticFieldInjectedBeforeSupertypeStaticMethods = true; } if (SpareTire.hasBeenStaticMethodInjected()) { - moreProblems.add("Subtype static method injected before supertype static method"); + subtypeStaticMethodInjectedBeforeSupertypeStaticMethods = true; } staticMethodInjection = methodInjection; } @Inject private void injectPrivateMethod() { if (superPrivateMethodInjected) { - moreProblems.add("Overridden private method injected twice"); + similarPrivateMethodInjectedTwice = true; } superPrivateMethodInjected = true; } @Inject void injectPackagePrivateMethod() { if (superPackagePrivateMethodInjected) { - moreProblems.add("Overridden package private method injected twice"); + similarPackagePrivateMethodInjectedTwice = true; } superPackagePrivateMethodInjected = true; } @Inject protected void injectProtectedMethod() { if (superProtectedMethodInjected) { - moreProblems.add("Overridden protected method injected twice"); + overriddenProtectedMethodInjectedTwice = true; } superProtectedMethodInjected = true; } @Inject public void injectPublicMethod() { if (superPublicMethodInjected) { - moreProblems.add("Overridden public method injected twice"); + overriddenPublicMethodInjectedTwice = true; } superPublicMethodInjected = true; } diff --git a/tck/org/atinject/tck/auto/V8Engine.java b/tck/org/atinject/tck/auto/V8Engine.java index a721cf9..2dc7473 100644 --- a/tck/org/atinject/tck/auto/V8Engine.java +++ b/tck/org/atinject/tck/auto/V8Engine.java @@ -16,7 +16,6 @@ package org.atinject.tck.auto; -import org.atinject.tck.Tester; import org.atinject.tck.auto.accessories.SpareTire; import javax.inject.Inject; @@ -29,10 +28,10 @@ public class V8Engine extends GasEngine { } @Inject void injectPackagePrivateMethod() { - if (packagePrivateMethodInjected) { - moreProblems.add("Overridden package private method injected twice"); + if (subPackagePrivateMethodInjected) { + overriddenPackagePrivateMethodInjectedTwice = true; } - packagePrivateMethodInjected = true; + subPackagePrivateMethodInjected = true; } /** @@ -44,12 +43,12 @@ public class V8Engine extends GasEngine { || !(seatB instanceof DriversSeat) || (tireA instanceof SpareTire) || !(tireB instanceof SpareTire)) { - moreProblems.add("Qualifiers inherited from overridden methods"); + qualifiersInheritedFromOverriddenMethod = true; } } void injectPackagePrivateMethodForOverride() { - packagePrivateMethodForOverrideInjected = true; + subPackagePrivateMethodForOverrideInjected = true; } @Inject public void injectTwiceOverriddenWithOmissionInMiddle() { @@ -59,18 +58,4 @@ public class V8Engine extends GasEngine { public void injectTwiceOverriddenWithOmissionInSubclass() { overriddenTwiceWithOmissionInSubclassInjected = true; } - - public void check(Tester tester) { - tester.addProblems(moreProblems); - - tester.test(publicNoArgsConstructorInjected, "Public no-args constructor not injected"); - tester.test(packagePrivateMethodInjected, "Packge private method not injected"); - tester.test(!packagePrivateMethodForOverrideInjected, - "Package private method injected, even though its override lacks @Inject"); - - tester.test(overriddenTwiceWithOmissionInMiddleInjected, - "Twice-overridden method not injected; middle override lacks @Inject"); - tester.test(!overriddenTwiceWithOmissionInSubclassInjected, - "Twice-overridden method injected, even though its override lacks @Inject"); - } } diff --git a/tck/org/atinject/tck/auto/accessories/Cupholder.java b/tck/org/atinject/tck/auto/accessories/Cupholder.java index 1a2ca6d..fec70a4 100644 --- a/tck/org/atinject/tck/auto/accessories/Cupholder.java +++ b/tck/org/atinject/tck/auto/accessories/Cupholder.java @@ -17,29 +17,18 @@ package org.atinject.tck.auto.accessories; import org.atinject.tck.auto.Seat; -import org.atinject.tck.Tester; -import javax.inject.Singleton; -import javax.inject.Provider; import javax.inject.Inject; -import java.util.List; -import java.util.ArrayList; +import javax.inject.Provider; +import javax.inject.Singleton; @Singleton public class Cupholder { - protected final List<String> moreProblems = new ArrayList<String>(); - - private final Provider<Seat> seatProvider; + public final Provider<Seat> seatProvider; @Inject public Cupholder(Provider<Seat> seatProvider) { this.seatProvider = seatProvider; } - - public void check(Tester tester) { - tester.addProblems(moreProblems); - - tester.test(seatProvider.get().getCupholder() == this, "Circularly dependent singletons not singleton"); - } } diff --git a/tck/org/atinject/tck/auto/accessories/SpareTire.java b/tck/org/atinject/tck/auto/accessories/SpareTire.java index 998574f..e9a7eb2 100644 --- a/tck/org/atinject/tck/auto/accessories/SpareTire.java +++ b/tck/org/atinject/tck/auto/accessories/SpareTire.java @@ -16,7 +16,6 @@ package org.atinject.tck.auto.accessories; -import org.atinject.tck.Tester; import org.atinject.tck.auto.FuelTank; import org.atinject.tck.auto.Tire; @@ -37,42 +36,42 @@ public class SpareTire extends Tire { @Inject void subtypeMethodInjection(FuelTank methodInjection) { if (!hasSpareTireBeenFieldInjected()) { - moreProblems.add("Methods injected before fields"); + methodInjectedBeforeFields = true; } this.methodInjection = methodInjection; } @Inject static void subtypeStaticMethodInjection(FuelTank methodInjection) { if (!hasBeenStaticFieldInjected()) { - moreProblems.add("Static methods injected before static fields"); + staticMethodInjectedBeforeStaticFields = true; } staticMethodInjection = methodInjection; } @Inject private void injectPrivateMethod() { if (subPrivateMethodInjected) { - moreProblems.add("Overridden private method injected twice"); + similarPrivateMethodInjectedTwice = true; } subPrivateMethodInjected = true; } @Inject void injectPackagePrivateMethod() { if (subPackagePrivateMethodInjected) { - moreProblems.add("Overridden package private method injected twice"); + similarPackagePrivateMethodInjectedTwice = true; } subPackagePrivateMethodInjected = true; } @Inject protected void injectProtectedMethod() { if (subProtectedMethodInjected) { - moreProblems.add("Overridden protected method injected twice"); + overriddenProtectedMethodInjectedTwice = true; } subProtectedMethodInjected = true; } @Inject public void injectPublicMethod() { if (subPublicMethodInjected) { - moreProblems.add("Overridden public method injected twice"); + overriddenPublicMethodInjectedTwice = true; } subPublicMethodInjected = true; } @@ -93,11 +92,11 @@ public class SpareTire extends Tire { publicMethodForOverrideInjected = true; } - protected boolean hasSpareTireBeenFieldInjected() { + public boolean hasSpareTireBeenFieldInjected() { return fieldInjection != NEVER_INJECTED; } - protected boolean hasSpareTireBeenMethodInjected() { + public boolean hasSpareTireBeenMethodInjected() { return methodInjection != NEVER_INJECTED; } @@ -108,44 +107,4 @@ public class SpareTire extends Tire { public static boolean hasBeenStaticMethodInjected() { return staticMethodInjection != NEVER_INJECTED; } - - /** - * This class is used to check inheritance. By existing in a separate package - * from Tire, it can make sure the injector does the right thing with overrides - * of package-private methods. - */ - public void check(Tester tester) { - tester.addProblems(moreProblems); - - tester.test(hasSpareTireBeenFieldInjected(), "Subtype fields not injected"); - tester.test(hasSpareTireBeenMethodInjected(), "Subtype methods not injected"); - tester.test(hasTireBeenFieldInjected(), "Supertype fields not injected"); - tester.test(hasTireBeenMethodInjected(), "Supertype methods not injected"); - tester.test(SpareTire.hasBeenStaticFieldInjected(), "Subtype static fields not injected"); - tester.test(SpareTire.hasBeenStaticMethodInjected(), "Subtype static methods not injected"); - tester.test(Tire.hasBeenStaticFieldInjected(), "Supertype static fields not injected"); - tester.test(Tire.hasBeenStaticMethodInjected(), "Supertype static methods not injected"); - - tester.test(superPrivateMethodInjected, "Supertype private method not injected"); - tester.test(superPackagePrivateMethodInjected, "Supertype private method not injected"); - tester.test(!superProtectedMethodInjected, "Overridden protected method injected!"); - tester.test(!superPublicMethodInjected, "Overridden public method injected!"); - tester.test(subPrivateMethodInjected, "Subtype private method not injected"); - tester.test(subPackagePrivateMethodInjected, "Subtype private method not injected"); - tester.test(subProtectedMethodInjected, "Subtype protected method not injected"); - tester.test(subPublicMethodInjected, "Subtype public method not injected"); - - tester.test(subPrivateMethodForOverrideInjected, - "Private method not injected when a subtype has a similar method that lacks @Inject"); - tester.test(subPackagePrivateMethodForOverrideInjected, - "Package private method not injected when a subtype has a similar method that lacks @Inject"); - tester.test(!superPrivateMethodForOverrideInjected, - "Private method injected when a supertype has a similar method annotated @Inject"); - tester.test(!superPackagePrivateMethodForOverrideInjected, - "Package private method injected when a supertype has a similar method annotated @Inject"); - tester.test(!protectedMethodForOverrideInjected, - "Protected method injected, even though its override lacks @Inject"); - tester.test(!publicMethodForOverrideInjected, - "Public method injected, even though its override lacks @Inject"); - } } |