Fixed bug where non-annotated fields in a @tested(fullyInitialized = …

…true) were erroneously initialized; closes #206.
jmockit · Sep 12, 2015 · 3f0bf2d · 3f0bf2d
1 parent 5cfc014
commit 3f0bf2d
Show file tree

Hide file tree

Showing 3 changed files with 26 additions and 11 deletions.
diff --git a/main/src/mockit/internal/expectations/injection/FieldInjection.java b/main/src/mockit/internal/expectations/injection/FieldInjection.java
@@ -21,26 +21,28 @@ final class FieldInjection
 {
    private static final Pattern TYPE_NAME = compile("class |interface |java\\.lang\\.");
 
-   @Nonnull private final TestedField testedField;
+   @Nonnull private final InjectionState injectionState;
+   boolean requireDIAnnotation;
    @Nonnull private final ProtectionDomain protectionDomainOfTestedClass;
    @Nullable private final String codeLocationParentPath;
    @Nonnull final String nameOfTestedClass;
-   @Nullable final FullInjection fullInjection;
+   @Nullable private final FullInjection fullInjection;
 
    FieldInjection(@Nonnull TestedField testedField, @Nonnull Class<?> testedClass, boolean fullInjection)
    {
-      this.testedField = testedField;
+      injectionState = testedField.injectionState;
+      requireDIAnnotation = testedField.requireDIAnnotation;
       protectionDomainOfTestedClass = testedClass.getProtectionDomain();
       CodeSource codeSource = protectionDomainOfTestedClass.getCodeSource();
       codeLocationParentPath = codeSource == null ? null : new File(codeSource.getLocation().getPath()).getParent();
       nameOfTestedClass = testedClass.getName();
-      this.fullInjection = fullInjection ? new FullInjection(testedField.injectionState) : null;
+      this.fullInjection = fullInjection ? new FullInjection(injectionState) : null;
    }
 
    @Nonnull
    List<Field> findAllTargetInstanceFieldsInTestedClassHierarchy(@Nonnull Class<?> testedClass)
    {
-      testedField.requireDIAnnotation = false;
+      requireDIAnnotation = false;
 
       List<Field> targetFields = new ArrayList<Field>();
       Class<?> classWithFields = testedClass;
@@ -72,7 +74,7 @@ private boolean isEligibleForInjection(@Nonnull Field field)
       boolean annotated = isAnnotated(field) != KindOfInjectionPoint.NotAnnotated;
 
       if (annotated) {
-         testedField.requireDIAnnotation = true;
+         requireDIAnnotation = true;
          return true;
       }
 
@@ -175,7 +177,6 @@ private static boolean notAssignedByConstructor(@Nonnull Field field, @Nonnull O
    @Nullable
    private Object getValueForFieldIfAvailable(@Nonnull List<Field> targetFields, @Nonnull Field fieldToBeInjected)
    {
-      InjectionState injectionState = testedField.injectionState;
       injectionState.setTypeOfInjectionPoint(fieldToBeInjected.getGenericType());
 
       String targetFieldName = fieldToBeInjected.getName();
@@ -195,7 +196,7 @@ private Object getValueForFieldIfAvailable(@Nonnull List<Field> targetFields, @N
       KindOfInjectionPoint kindOfInjectionPoint = isAnnotated(fieldToBeInjected);
 
       if (fullInjection != null) {
-         if (testedField.requireDIAnnotation && kindOfInjectionPoint == KindOfInjectionPoint.NotAnnotated) {
+         if (requireDIAnnotation && kindOfInjectionPoint == KindOfInjectionPoint.NotAnnotated) {
             return null;
          }
 
@@ -226,8 +227,6 @@ private Object getValueForFieldIfAvailable(@Nonnull List<Field> targetFields, @N
    private boolean withMultipleTargetFieldsOfSameType(
       @Nonnull List<Field> targetFields, @Nonnull Field fieldToBeInjected)
    {
-      InjectionState injectionState = testedField.injectionState;
-
       for (Field targetField : targetFields) {
          if (
             targetField != fieldToBeInjected &&
@@ -243,13 +242,17 @@ private boolean withMultipleTargetFieldsOfSameType(
    void fillOutDependenciesRecursively(@Nonnull Object dependency)
    {
       Class<?> dependencyClass = dependency.getClass();
+      boolean previousRequireDIAnnotation = requireDIAnnotation;
       List<Field> targetFields = findAllTargetInstanceFieldsInTestedClassHierarchy(dependencyClass);
 
       if (!targetFields.isEmpty()) {
-         InjectionState injectionState = testedField.injectionState;
          List<MockedType> currentlyConsumedInjectables = injectionState.saveConsumedInjectables();
+
          injectIntoEligibleFields(targetFields, dependency);
+
          injectionState.restoreConsumedInjectables(currentlyConsumedInjectables);
       }
+
+      requireDIAnnotation = previousRequireDIAnnotation;
    }
 }
diff --git a/main/src/mockit/internal/expectations/injection/TestedField.java b/main/src/mockit/internal/expectations/injection/TestedField.java
@@ -70,6 +70,7 @@ void instantiateWithInjectableValues(@Nonnull Object testClassInstance)
 
          if (targetFields == null) {
             targetFields = fieldInjection.findAllTargetInstanceFieldsInTestedClassHierarchy(testedClass);
+            requireDIAnnotation = fieldInjection.requireDIAnnotation;
          }
 
          fieldInjection.injectIntoEligibleFields(targetFields, testedObject);

diff --git a/main/test/mockit/TestedClassWithFullAnnotatedDITest.java b/main/test/mockit/TestedClassWithFullAnnotatedDITest.java
@@ -22,8 +22,12 @@ static final class TestedClass
       @Inject ItfWithTwoImplsButOnlyOneLoaded anotherDependency;
       @Inject private Logger log1;
       @Inject private Logger log2;
+      Logger log3;
+      Value value;
    }
 
+   static final class Value {}
+
    public interface ItfWithSingleLoadedImpl {}
    public static final class SingleLoadedImpl implements ItfWithSingleLoadedImpl { @EJB ItfWithTwoLoadedImpls ejb; }
 
@@ -66,4 +70,11 @@ public void injectLoggerFieldsWithLoggerCreatedWithTestedClassName()
       assertEquals(TestedClass.class.getName(), tested.log1.getName());
       assertSame(tested.log2, tested.log1);
    }
+
+   @Test
+   public void leaveNonAnnotatedFieldsUninitialized()
+   {
+      assertNull(tested.value);
+      assertNull(tested.log3);
+   }
 }