diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/AllocationOnGap.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/AllocationAttempt.java
similarity index 90%
rename from navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/AllocationOnGap.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/AllocationAttempt.java
index 63154a82f..e6814c605 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/AllocationOnGap.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/AllocationAttempt.java
@@ -32,21 +32,21 @@ import org.navalplanner.business.planner.entities.SpecificDayAssignment;
 import org.navalplanner.business.planner.entities.SpecificResourceAllocation;
 import org.navalplanner.business.resources.entities.Resource;
 
-public abstract class AllocationOnGap {
+public abstract class AllocationAttempt {
 
-    public static AllocationOnGap invalidOn(Gap gap) {
-        return new InvalidAllocationOnGap(gap);
+    public static AllocationAttempt invalidOn(Gap gap) {
+        return new InvalidAllocationAttempt(gap);
     }
 
-    public static AllocationOnGap validOn(Gap gap, DateAndHour start,
+    public static AllocationAttempt validOn(Gap gap, DateAndHour start,
             DateAndHour endExclusive, int[] assignableHours) {
-        return new ValidAllocationOnGap(gap, start, endExclusive,
+        return new ValidAllocationAttempt(gap, start, endExclusive,
                 assignableHours);
     }
 
     private final Gap originalGap;
 
-    protected AllocationOnGap(Gap originalGap) {
+    protected AllocationAttempt(Gap originalGap) {
         Validate.notNull(originalGap);
         this.originalGap = originalGap;
     }
@@ -67,11 +67,11 @@ public abstract class AllocationOnGap {
     }
 }
 
-class InvalidAllocationOnGap extends AllocationOnGap {
+class InvalidAllocationAttempt extends AllocationAttempt {
 
     private static final String INVALID_ALLOCATION_ON_GAP = "invalid allocation on gap";
 
-    InvalidAllocationOnGap(Gap originalGap) {
+    InvalidAllocationAttempt(Gap originalGap) {
         super(originalGap);
     }
 
@@ -97,13 +97,13 @@ class InvalidAllocationOnGap extends AllocationOnGap {
     }
 }
 
-class ValidAllocationOnGap extends AllocationOnGap {
+class ValidAllocationAttempt extends AllocationAttempt {
 
     private final DateAndHour start;
     private final DateAndHour end;
     private final int[] assignableHours;
 
-    public ValidAllocationOnGap(Gap gap, DateAndHour startInclusive,
+    public ValidAllocationAttempt(Gap gap, DateAndHour startInclusive,
             DateAndHour endExclusive, int[] assignableHours) {
         super(gap);
         Validate.notNull(startInclusive);
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/GapRequirements.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/InsertionRequirements.java
similarity index 92%
rename from navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/GapRequirements.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/InsertionRequirements.java
index 34c5c568b..8355df9d8 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/GapRequirements.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/limiting/entities/InsertionRequirements.java
@@ -33,7 +33,7 @@ import org.navalplanner.business.resources.entities.Resource;
 /**
  * @author Óscar González Fernández <ogonzalez@igalia.com>
  */
-public class GapRequirements {
+public class InsertionRequirements {
 
     private final LimitingResourceQueueElement element;
 
@@ -41,11 +41,11 @@ public class GapRequirements {
 
     private final DateAndHour earliestPossibleEnd;
 
-    public static GapRequirements forElement(
+    public static InsertionRequirements forElement(
             LimitingResourceQueueElement element,
             List<LimitingResourceQueueDependency> dependenciesAffectingStart,
             List<LimitingResourceQueueDependency> dependenciesAffectingEnd) {
-        return new GapRequirements(element, calculateEarliestPossibleStart(
+        return new InsertionRequirements(element, calculateEarliestPossibleStart(
                 element, dependenciesAffectingStart),
                 calculateEarliestPossibleEnd(element, dependenciesAffectingEnd));
     }
@@ -80,7 +80,7 @@ public class GapRequirements {
         return DateAndHour.from(LocalDate.fromDateFields(date));
     }
 
-    private GapRequirements(LimitingResourceQueueElement element,
+    private InsertionRequirements(LimitingResourceQueueElement element,
             DateAndHour earliestPossibleStart, DateAndHour earliestPossibleEnd) {
         Validate.notNull(element);
         Validate.notNull(earliestPossibleStart);
@@ -97,10 +97,10 @@ public class GapRequirements {
                         .isAfter(gapEnd));
     }
 
-    public AllocationOnGap guessValidity(GapOnQueue gapOnQueue) {
+    public AllocationAttempt guessValidity(GapOnQueue gapOnQueue) {
         Gap gap = gapOnQueue.getGap();
         if (!isPotentiallyValid(gap)) {
-            return AllocationOnGap.invalidOn(gap);
+            return AllocationAttempt.invalidOn(gap);
         }
         DateAndHour realStart = DateAndHour.Max(earliestPossibleStart, gap
                 .getStartTime());
@@ -110,7 +110,7 @@ public class GapRequirements {
                 earliestPossibleEnd, element.getIntentedTotalHours());
         int total = sum(hours);
         if (total < element.getIntentedTotalHours()) {
-            return AllocationOnGap.invalidOn(gap);
+            return AllocationAttempt.invalidOn(gap);
         } else if (total == element.getIntentedTotalHours()) {
             return validAllocation(gap, realStart, hours);
         } else {
@@ -123,9 +123,9 @@ public class GapRequirements {
 
     }
 
-    private AllocationOnGap validAllocation(Gap gap, DateAndHour realStart,
+    private AllocationAttempt validAllocation(Gap gap, DateAndHour realStart,
             List<Integer> hours) {
-        return AllocationOnGap.validOn(gap, realStart, calculateEnd(realStart,
+        return AllocationAttempt.validOn(gap, realStart, calculateEnd(realStart,
                 hours), asArray(hours));
     }
 
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/LimitingResourceQueue.java b/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/LimitingResourceQueue.java
index ba97a509c..bb215d70f 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/LimitingResourceQueue.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/LimitingResourceQueue.java
@@ -29,7 +29,7 @@ import java.util.TreeSet;
 import org.navalplanner.business.common.BaseEntity;
 import org.navalplanner.business.planner.limiting.entities.DateAndHour;
 import org.navalplanner.business.planner.limiting.entities.Gap;
-import org.navalplanner.business.planner.limiting.entities.GapRequirements;
+import org.navalplanner.business.planner.limiting.entities.InsertionRequirements;
 import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueElement;
 import org.navalplanner.business.planner.limiting.entities.Gap.GapOnQueue;
 
@@ -105,7 +105,7 @@ public class LimitingResourceQueue extends BaseEntity {
      *         <code>requirements</code> ordered by start date
      */
     public List<GapOnQueue> getGapsPotentiallyValidFor(
-            GapRequirements requirements) {
+            InsertionRequirements requirements) {
         List<GapOnQueue> result = new ArrayList<GapOnQueue>();
         for (GapOnQueue each : getGaps()) {
             if (requirements.isPotentiallyValid(each.getGap())) {
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/LimitingResourceQueueModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/LimitingResourceQueueModel.java
index 00824201b..5d70fa971 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/LimitingResourceQueueModel.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/LimitingResourceQueueModel.java
@@ -52,10 +52,10 @@ import org.navalplanner.business.planner.entities.TaskElement;
 import org.navalplanner.business.planner.limiting.daos.ILimitingResourceQueueDAO;
 import org.navalplanner.business.planner.limiting.daos.ILimitingResourceQueueDependencyDAO;
 import org.navalplanner.business.planner.limiting.daos.ILimitingResourceQueueElementDAO;
-import org.navalplanner.business.planner.limiting.entities.AllocationOnGap;
+import org.navalplanner.business.planner.limiting.entities.AllocationAttempt;
 import org.navalplanner.business.planner.limiting.entities.DateAndHour;
 import org.navalplanner.business.planner.limiting.entities.Gap;
-import org.navalplanner.business.planner.limiting.entities.GapRequirements;
+import org.navalplanner.business.planner.limiting.entities.InsertionRequirements;
 import org.navalplanner.business.planner.limiting.entities.LimitingResourceAllocator;
 import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueDependency;
 import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueElement;
@@ -383,7 +383,7 @@ public class LimitingResourceQueueModel implements ILimitingResourceQueueModel {
         List<LimitingResourceQueueElement> result = new ArrayList<LimitingResourceQueueElement>();
         for (LimitingResourceQueueElement each : queuesState
                 .getInsertionsToBeDoneFor(externalQueueElement)) {
-            GapRequirements requirements = queuesState.getRequirementsFor(each);
+            InsertionRequirements requirements = queuesState.getRequirementsFor(each);
             boolean inserted = insert(requirements);
             if (!inserted) {
                 break;
@@ -393,14 +393,14 @@ public class LimitingResourceQueueModel implements ILimitingResourceQueueModel {
         return result;
     }
 
-    private boolean insert(GapRequirements requirements) {
+    private boolean insert(InsertionRequirements requirements) {
         List<GapOnQueue> potentiallyValidGapsFor = queuesState
                 .getPotentiallyValidGapsFor(requirements);
         boolean generic = requirements.getElement().isGeneric();
         for (GapOnQueue each : potentiallyValidGapsFor) {
             for (GapOnQueue eachSubGap : getSubGaps(each, requirements
                     .getElement(), generic)) {
-                AllocationOnGap allocation = requirements
+                AllocationAttempt allocation = requirements
                         .guessValidity(eachSubGap);
                 if (allocation.isValid()) {
                     doAllocation(requirements, allocation, eachSubGap.getOriginQueue());
@@ -419,8 +419,8 @@ public class LimitingResourceQueueModel implements ILimitingResourceQueueModel {
         return Collections.singletonList(each);
     }
 
-    private void doAllocation(GapRequirements requirements,
-            AllocationOnGap allocation, LimitingResourceQueue queue) {
+    private void doAllocation(InsertionRequirements requirements,
+            AllocationAttempt allocation, LimitingResourceQueue queue) {
         Resource resource = queue.getResource();
         ResourceAllocation<?> resourceAllocation = requirements
                 .getElement().getResourceAllocation();
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/QueuesState.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/QueuesState.java
index 0d5aafb3b..143084d28 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/QueuesState.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/limitingresources/QueuesState.java
@@ -37,7 +37,7 @@ import org.navalplanner.business.common.BaseEntity;
 import org.navalplanner.business.planner.entities.GenericResourceAllocation;
 import org.navalplanner.business.planner.entities.ResourceAllocation;
 import org.navalplanner.business.planner.entities.SpecificResourceAllocation;
-import org.navalplanner.business.planner.limiting.entities.GapRequirements;
+import org.navalplanner.business.planner.limiting.entities.InsertionRequirements;
 import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueDependency;
 import org.navalplanner.business.planner.limiting.entities.LimitingResourceQueueElement;
 import org.navalplanner.business.planner.limiting.entities.Gap.GapOnQueue;
@@ -207,12 +207,12 @@ public class QueuesState {
         throw new RuntimeException("unexpected type of: " + resourceAllocation);
     }
 
-    public GapRequirements getRequirementsFor(
+    public InsertionRequirements getRequirementsFor(
             LimitingResourceQueueElement element) {
         List<LimitingResourceQueueDependency> dependenciesStart = new ArrayList<LimitingResourceQueueDependency>();
         List<LimitingResourceQueueDependency> dependenciesEnd = new ArrayList<LimitingResourceQueueDependency>();
         fillIncoming(element, dependenciesStart, dependenciesEnd);
-        return GapRequirements.forElement(getEquivalent(element),
+        return InsertionRequirements.forElement(getEquivalent(element),
                 dependenciesStart, dependenciesEnd);
     }
 
@@ -253,7 +253,7 @@ public class QueuesState {
      *         ordered by start date
      */
     public List<GapOnQueue> getPotentiallyValidGapsFor(
-            GapRequirements requirements) {
+            InsertionRequirements requirements) {
         List<LimitingResourceQueue> assignableQueues = getAssignableQueues(requirements
                 .getElement());
         List<List<GapOnQueue>> allGaps = gapsFor(assignableQueues, requirements);
@@ -262,7 +262,7 @@ public class QueuesState {
 
     private List<List<GapOnQueue>> gapsFor(
             List<LimitingResourceQueue> assignableQueues,
-            GapRequirements requirements) {
+            InsertionRequirements requirements) {
         List<List<GapOnQueue>> result = new ArrayList<List<GapOnQueue>>();
         for (LimitingResourceQueue each : assignableQueues) {
             result.add(each.getGapsPotentiallyValidFor(requirements));