Bug 319728 - Uninjection of primitive values is broken
diff --git a/bundles/org.eclipse.e4.core.di/src/org/eclipse/e4/core/internal/di/InjectorImpl.java b/bundles/org.eclipse.e4.core.di/src/org/eclipse/e4/core/internal/di/InjectorImpl.java
index 8db578d..ecfe02b 100644
--- a/bundles/org.eclipse.e4.core.di/src/org/eclipse/e4/core/internal/di/InjectorImpl.java
+++ b/bundles/org.eclipse.e4.core.di/src/org/eclipse/e4/core/internal/di/InjectorImpl.java
@@ -52,6 +52,15 @@
final static private String JAVA_OBJECT = "java.lang.Object"; //$NON-NLS-1$
+ final private static Boolean DEFAULT_BOOLEAN = new Boolean(false);
+ final private static Integer DEFAULT_INTEGER = new Integer(0);
+ final private static Character DEFAULT_CHAR = new Character((char) 0);
+ final private static Float DEFAULT_FLOAT = new Float(0.0f);
+ final private static Double DEFAULT_DOUBLE = new Double(0.0d);
+ final private static Long DEFAULT_LONG = new Long(0L);
+ final private static Short DEFAULT_SHORT = new Short((short) 0);
+ final private static Byte DEFAULT_BYTE = new Byte((byte) 0);
+
private Map<PrimaryObjectSupplier, List<WeakReference<?>>> injectedObjects = new HashMap<PrimaryObjectSupplier, List<WeakReference<?>>>();
private Set<WeakReference<Class<?>>> injectedClasses = new HashSet<WeakReference<Class<?>>>();
private HashMap<Class<?>, Object> singletonCache = new HashMap<Class<?>, Object>();
@@ -428,13 +437,31 @@
if (!descriptorsClass.isAssignableFrom(actualArgs[i].getClass()))
actualArgs[i] = IInjector.NOT_A_VALUE;
}
- // replace optional unresolved values with null
- if (actualArgs[i] == IInjector.NOT_A_VALUE && descriptors[i].hasQualifier(Optional.class))
- actualArgs[i] = null;
- else if (fillNulls && actualArgs[i] == IInjector.NOT_A_VALUE)
- actualArgs[i] = null;
+ if (actualArgs[i] == IInjector.NOT_A_VALUE) { // still unresolved?
+ if (fillNulls || descriptors[i].hasQualifier(Optional.class)) { // uninject or optional - fill defaults
+ Class<?> descriptorsClass = getDesiredClass(descriptors[i].getDesiredType());
+ if (descriptorsClass.isPrimitive()) {
+ if (descriptorsClass.equals(boolean.class))
+ actualArgs[i] = DEFAULT_BOOLEAN;
+ else if (descriptorsClass.equals(int.class))
+ actualArgs[i] = DEFAULT_INTEGER;
+ else if (descriptorsClass.equals(char.class))
+ actualArgs[i] = DEFAULT_CHAR;
+ else if (descriptorsClass.equals(float.class))
+ actualArgs[i] = DEFAULT_FLOAT;
+ else if (descriptorsClass.equals(double.class))
+ actualArgs[i] = DEFAULT_DOUBLE;
+ else if (descriptorsClass.equals(long.class))
+ actualArgs[i] = DEFAULT_LONG;
+ else if (descriptorsClass.equals(short.class))
+ actualArgs[i] = DEFAULT_SHORT;
+ else if (descriptorsClass.equals(byte.class))
+ actualArgs[i] = DEFAULT_BYTE;
+ } else
+ actualArgs[i] = null;
+ }
+ }
}
-
return actualArgs;
}
diff --git a/tests/org.eclipse.e4.core.tests/src/org/eclipse/e4/core/internal/tests/di/InjectBaseTypeTest.java b/tests/org.eclipse.e4.core.tests/src/org/eclipse/e4/core/internal/tests/di/InjectBaseTypeTest.java
index 74935f3..18360d4 100644
--- a/tests/org.eclipse.e4.core.tests/src/org/eclipse/e4/core/internal/tests/di/InjectBaseTypeTest.java
+++ b/tests/org.eclipse.e4.core.tests/src/org/eclipse/e4/core/internal/tests/di/InjectBaseTypeTest.java
@@ -18,6 +18,7 @@
import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.EclipseContextFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
+import org.eclipse.e4.core.di.annotations.Optional;
/**
* Checks conversion of primitive types
@@ -28,6 +29,9 @@
@Inject @Named("test_int")
public int intField;
+ @Inject @Named("test_int_optional") @Optional
+ public int intFieldOptional;
+
@Inject @Named("test_long")
public long longField;
@@ -76,6 +80,7 @@
TestClass testClass = ContextInjectionFactory.make(TestClass.class, context);
assertEquals(12, testClass.intField);
+ assertEquals(0, testClass.intFieldOptional);
assertEquals(124564523466L, testClass.longField);
assertEquals(12.34f, testClass.floatField);
assertEquals(12.34534534563463466546d, testClass.doubleField);
@@ -87,5 +92,23 @@
assertEquals(12, testClass.intArg);
assertEquals('a', testClass.charArg);
assertEquals(true, testClass.booleanArg);
+
+ // test end-of-life reset of values
+ ContextInjectionFactory.uninject(testClass, context);
+
+ assertEquals(0, testClass.intField);
+ assertEquals(0, testClass.intFieldOptional);
+ assertEquals(0L, testClass.longField);
+ assertEquals(0f, testClass.floatField);
+ assertEquals(0.0d, testClass.doubleField);
+ assertEquals((short)0, testClass.shortField);
+ assertEquals((byte)0, testClass.byteField);
+ assertEquals(false, testClass.booleanField);
+ assertEquals((char)0, testClass.charField);
+
+ assertEquals(0, testClass.intArg);
+ assertEquals((char)0, testClass.charArg);
+ assertEquals(false, testClass.booleanArg);
+
}
}
