import static org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil.isPortResource;
 import static org.openecomp.sdc.translator.services.heattotosca.ConsolidationDataUtil.isVolumeResource;
 
-import java.util.*;
-import java.util.stream.Collectors;
-
 import org.openecomp.sdc.heat.datatypes.model.Resource;
 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
 
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
 /**
  * The enum Entity type.
  */
             consolidationEntityType = ConsolidationEntityType.COMPUTE;
         } else if (isPortResource(resource)) {
             consolidationEntityType = ConsolidationEntityType.PORT;
+        } else if (HeatToToscaUtil.isSubInterfaceResource(resource, context)) {
+            consolidationEntityType = ConsolidationEntityType.SUB_INTERFACE;
         } else if (isVolumeResource(resource)) {
             consolidationEntityType = ConsolidationEntityType.VOLUME;
         } else if (HeatToToscaUtil.isNestedResource(resource)) {
         }
         return consolidationEntityType;
     }
-
-    public static boolean isEntityTypeNested(ConsolidationEntityType entityType) {
-        return NESTED == entityType || VFC_NESTED == entityType;
-    }
 }
\ No newline at end of file
 
     }
 
     static boolean isDependsOnRelationshipValid(ConsolidationEntityType source, ConsolidationEntityType target) {
-        return !eitherSourceOrTargetIsNested(source, target)
-                       && (!entityToEntitiesWithoutRelationship.containsKey(source)
-                                   || !entityToEntitiesWithoutRelationship.containsEntry(source, target));
-    }
-
-    private static boolean eitherSourceOrTargetIsNested(ConsolidationEntityType source,
-                                                               ConsolidationEntityType target) {
-        return ConsolidationEntityType.isEntityTypeNested(source) || ConsolidationEntityType.isEntityTypeNested(target);
+        return !entityToEntitiesWithoutRelationship.containsKey(source)
+                                   || !entityToEntitiesWithoutRelationship.containsEntry(source, target);
     }
 }
 
       Resource targetResource = HeatToToscaUtil
           .getResource(heatOrchestrationTemplate, dependsOnResourceId,
               translateTo.getHeatFileName());
-      if (HeatToToscaUtil
-          .isValidDependsOnCandidate(sourceResource, targetResource,
-              ConsolidationEntityType.OTHER, translateTo.getContext())) {
+      if (isValidDependency(sourceResource, targetResource, translateTo)) {
         requirementAssignment.setNode(resourceTranslatedId.get());
         requirementAssignment.setCapability(ToscaCapabilityType.NATIVE_NODE);
         requirementAssignment.setRelationship(ToscaRelationshipType.NATIVE_DEPENDS_ON);
     }
   }
 
+  private boolean isValidDependency(Resource sourceResource, Resource targetResource, TranslateTo translateTo) {
+      return !(HeatToToscaUtil.isNestedResource(sourceResource) || HeatToToscaUtil.isNestedResource(targetResource))
+              && HeatToToscaUtil.isValidDependsOnCandidate(sourceResource, targetResource,
+              ConsolidationEntityType.OTHER, translateTo.getContext());
+  }
+
   Optional<List<Map.Entry<String, Resource>>> getResourceByTranslatedResourceId(
       String heatFileName,
       HeatOrchestrationTemplate heatOrchestrationTemplate,
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.commons.collections4.CollectionUtils;
 import org.junit.Assert;
-import org.openecomp.sdc.tosca.datatypes.ToscaCapabilityType;
 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
-import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
 import org.onap.sdc.tosca.datatypes.model.GroupDefinition;
 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
 import org.onap.sdc.tosca.datatypes.model.NodeType;
                                                                nestedTemplateConsolidationData) {
     Assert.assertNull(nestedTemplateConsolidationData.getGroupIds());
     Assert.assertNull(nestedTemplateConsolidationData.getNodesConnectedOut());
-    //Assert.assertNull(nestedTemplateConsolidationData.getNodesGetAttrOut());
-  }
-
-  private static void validateNestedNodesConnectedInDependency(Map<String,
-                                                  List<RequirementAssignmentData>> nodesConnectedIn,
-                                                           String nestedNodeTemplateId,
-                                                           List<String> dependentNodeTemplateIds) {
-    Assert.assertNotNull(nodesConnectedIn);
-    for (String dependentNodeTemplateId : dependentNodeTemplateIds) {
-      List<RequirementAssignmentData> requirementAssignmentData =
-          nodesConnectedIn.get(dependentNodeTemplateId);
-      Assert.assertNotNull(requirementAssignmentData);
-      for (RequirementAssignmentData data : requirementAssignmentData) {
-        Assert.assertEquals(data.getRequirementId(), ToscaConstants.DEPENDS_ON_REQUIREMENT_ID);
-        Assert.assertEquals(data.getRequirementAssignment().getCapability(), ToscaCapabilityType
-            .NATIVE_NODE);
-        Assert.assertEquals(data.getRequirementAssignment().getNode(), nestedNodeTemplateId);
-        Assert.assertEquals(data.getRequirementAssignment().getRelationship(),
-            ToscaRelationshipType.NATIVE_DEPENDS_ON);
-      }
-    }
   }
 
   public static void validateNestedNodesConnectedInSecurityRuleToPort(String testName,